Patent Description:
<CIT> discloses a method for automatically estimating a repair cost for a vehicle. The method includes: receiving, at a server computing device over an electronic network, one or more images of a damaged vehicle from a client computing device; performing image processing operations on each of the one or more images to detect external damage to a first set of parts of the vehicle; inferring internal damage to a second set of parts of the vehicle based on the detected external damage; and, calculating an estimated repair cost for the vehicle based on the detected external damage and inferred internal damage based on accessing a parts database that includes repair and labor costs for each part in the first and second sets of parts.

<CIT> discloses techniques for rental vehicle damage detection and automatic rental vehicle management. A rental vehicle management application receives video and/or images of a rental vehicle's exterior and dashboard and processes the video and/or images to determine damage to the vehicle as well as the vehicle's mileage and fuel level. A machine learning model is trained using image sets, extracted from larger images of vehicles, that depict distinct types of damage to vehicles, as well as image sets depicting undamaged vehicles, and the management application may apply such a machine learning model to identify and classify vehicle damage. The management application determines sizes of vehicle damage by converting the damage sizes in pixels to real-world units, and the management application then generates a report and receipt indicating the damage to the vehicle if any, mileage, fuel level, and associated costs.

<CIT> discloses image analysis techniques that automatically assess the damage to a rooftop of a building or other object. The system determines the extent of the damage, as well as the type of damage. Further aspects provide for the automatic detection of the roof type, roof geometry, shingle or tile count, or other features that can be extracted from images of the rooftop.

Features of the present disclosure are illustrated by way of examples shown in the following figures. In the following figures, like numerals indicate like elements, in which:.

For simplicity and illustrative purposes, the present disclosure is described by referring to examples thereof. It will be readily apparent however that the present disclosure may be practiced without limitation to these specific details.

An Al-based automatic damage detection and estimation system that employs ML models to analyze images to not only determine a cause of damage but also to assess the extent of damage and the cost of restoring or repairing the damaged object is disclosed. In an implementation, a damaged object is photographed or captured on video from different angles and on different sides. The images can be uploaded to an estimation system via a mobile app or the images may be captured using the mobile app. In an example, the mobile app can instruct the user recording the images or Videos to capture images in black and white (B/W) or monochrome versions or RGB. In an example, the damage detection and estimation system can convert the received images to B/W versions when images are captured in color.

The B/W and or RGB images are analyzed by a cause prediction model which is an ensemble ML model that is used to identify a cause of damage for the damaged object. The cause can be identified from a plurality of causes associated with a particular object category of the damaged object. For example, if the damaged object is a vehicle, then the plurality of causes may pertain to reasons or situations that damage vehicles such as, collisions, hailstorms, natural perils and the like. Similarly, different object categories for which damages are identified and costs estimated can be associated with a corresponding plurality of causes. In an example, the ensemble cause prediction model enables local feature extraction. The ensemble cause prediction model can include different sub-models representing different cause hypotheses about different angles in which the object appears in the received images. Each sub-model of the ensemble cause prediction model can be trained to output a class (or a selected cause from the plurality of causes) with a probability percentage. In the final step executed by the ensemble cause prediction model, an average (Y_average) of class probabilities from different sub-models is calculated and the class with the maximum probability is provided as the cause of damage.

In an example, each sub-model that make up the ensemble cause prediction model includes a CNN which can be trained on labeled data via supervised training to identify a cause of damage to one part of the damaged object from the plurality of causes. In an example, the labeled data can include B/W or RGB images including the same or similar parts from different damaged and non-damaged objects that belong to the same object category as the damaged object and which are labeled with their corresponding damage causes from the plurality of causes associated with that particular object category.

The final output from the ensemble cause prediction model therefore includes a cause of damage for the damaged object captured in the images. In addition, an explanation for the selection of the cause from the plurality of causes can also be extracted from the individual CNNs that constitute the sub-models of the ensemble cause prediction model. The explanation can include, or reference, specific portions of the images and particular image pixels that enabled the cause prediction models to select or identify the cause from the plurality of causes. In an example, a visualization technique can include gradient-weighted Class Activation Mapping (Grad-CAM) which enables each of the CNNs comprising the sub-models to produce coarse localization maps of important regions of the images or the image portions that lead to the selection of the cause from the plurality of causes. In an example, another visualization technique can include Guided Grad-CAM which enables extracting the particular image pixels that contributed to the identification of the cause from the plurality of causes by the cause prediction models. In another example using filter visualization technique enables visualizations of local and global image pixels that contributed to the identification of the cause from the plurality of causes by the cause prediction models.

The damage detection and estimation system further includes an ML parts identification model that identifies and labels the parts and the states of the various parts of the damaged object from the images. The output from the parts identification model can include one or more images of the damaged object with parts identified and annotated with corresponding states. In an example, the parts identification model can include a Faster Region-based convolution neural network (Faster R-CNN). The Faster R-CNN model is also trained on labeled training data that includes images of other objects belonging to the object category of the damaged object. The images of the other objects are labeled with the various parts in different states. Different objects of the same object category labeled with respective parts and annotated with their corresponding states such as damaged, non-damaged, repair annotations and replace annotations are included in the training data for the parts identification model. When the parts identification model is able to identify the parts the extent of damage is estimated as a percentage of damaged parts versus the non-damaged parts. Based on the parts requiring replacement or repairs, a cost of restoration can be estimated for the damaged object. In an example, third party dealers, original equipment manufacturers (OEMs) or other websites can be accessed in order to retrieve the costs for replacements and repairs. A final output from the damage detection and estimation system in response to the images of the damaged object includes a report with one or more of the cause of damage, an explanation for the selection of the cause, the parts that were non-damaged, repairable or need replacements, the extent of damage and the cost for repairs or restoration of the damaged object.

In an example, the damage detection and estimation system is modularized in that the cause prediction model and the parts identification model can operate independently. Therefore, for situations where only the damage cause prediction is needed, the cause prediction model can be employed. Similarly, in situations where the damage cause is known or not required but a cost of repairs is needed, the parts identification model can be employed.

The damage detection and estimation system as disclosed and described herein provides a technical solution to a technical problem that enables a touchless tool for analyzing digital images of the damaged object and identifying a cause of damage, the exact repairs and replacements required and the cost of restoration. The damage detection and estimation system is configured to analyze damage to an object as a multi-class classification problem with the damage being classified under one of the plurality of causes based on the received images. Currently CNNs are the tools of choice for image analysis tasks. However, unlike basic ML algorithms like decision tress whose output can be explained by following the tree paths leading to the decisions, deep layers of complex ML algorithms, such as CNNs, are often incomprehensible and opaque so that it can be difficult to understand or explain why a certain result has been produced. Increasing data privacy and other regulatory issues can hinder adoption of CNNs in practical computer systems due to their black box approach to decision making.

The disclosed damage detection and estimation system improves on existing image analysis systems initially by providing the ensemble cause prediction model including different sub-models that are trained on different parts of the damaged object to identify the cause of damage. While various ML models can be employed for different tasks, each model has its strengths and weaknesses. Therefore, using a single ML model for predicting a cause of damage can result in lower precision and high error rate due to the high dimensionality of the damaged object. The use of the ensemble cause prediction model is that stacking different sub-models representing different hypotheses of different objects can lead to a better hypothesis which may not be present in separate hypotheses spaces corresponding to the individual models that make up the ensemble. A combination of different sub-models wherein each model is trained on one portion or one part of the object lowers error rate and in addition to achieving good precision.

Another improvement afforded by the damage detection and estimation system is that the CNNs that make up the sub-models of the ensemble cause prediction model are configured to provide visualizations as explanations of why a particular cause was selected from the plurality of causes. Such explanations not only include the portions of the images but also the particular pixels that caused the ML models to select the specific cause. The black box nature of CNN-based models is mitigated by providing a readily understood explanation for the output from the CNNs. Furthermore, the use of monochrome or B/W images for the cause identification and in the training data for training the ML models improves accuracy of the ML models. In addition to the cause of damage and an explanation regarding the cause of damage, the cost for repairs is also automatically recovered from local or external data sources. The damage detection and estimation system therefore improves computer systems by programming a computer system as an automatic one-stop touchless technical solution for damage assessment and restoration. In addition, the use of monochrome or B/W images allows computers to perform accurate analyses using less memory and using fewer processing resources (e.g., computing cycles) than are required if color images are used. Moreover, while the use of B/W images improves accuracy, the images of damaged objects can still include a lot of clutter. Therefore, the use of the ensemble cause prediction model trained with local features when used in consonance with the monochrome or B/W images can lead to improved precision and accuracy.

<FIG> is a block diagram of an Al-based automatic damage detection and estimation system <NUM> in accordance with the examples disclosed herein. The damage detection and estimation system <NUM> includes a data retriever <NUM>, a cause predictor <NUM>, a parts identifier <NUM> and a cost estimator <NUM>. In addition, the damage detection and estimation system <NUM> also includes a models trainer <NUM> that trains different ML models for carrying out different tasks as detailed herein. The data retriever <NUM> receives images <NUM> of a damaged object. The damage detection and estimation system <NUM> may also be connected to a data store <NUM> for storing inputs such as the images <NUM> and the outputs that are produced as detailed further herein. The images <NUM> can include colored or B/W still photographs or videos which are captured by different cameras such as individual camera devices or cameras included in a smartphone, tablet, or other device. Different sides of the damaged object are captured from different angles in the images <NUM>.

The images <NUM> are accessed by the cause predictor <NUM> which analyzes the images <NUM> to determine or predict a cause for the damaged object. The cause for the damage can be identified from a plurality of causes that are predetermined for an object category associated with the damaged object. Different objects of the object category may have different causes for damages. Also, different types of damage to an object may result due to different causes. The cause predictor <NUM> can be configured to identify a cause <NUM> from a plurality of causes <NUM> for the damage captured in the images <NUM> by analyzing the images <NUM> using a cause prediction model <NUM>. The cause prediction model <NUM> is an ensemble ML model that is trained via supervised training on image data labeled with various causes. The model training will be discussed in detail further herein. The output <NUM> from the cause predictor <NUM> therefore includes a cause <NUM> for the damage to the damaged object in the images <NUM>. In an example the cause prediction model <NUM> can be made up of multiple sub-models <NUM> where each sub-model includes a customized CNN.

Additionally, the cause predictor <NUM> also outputs an explanation <NUM> for the selection of the cause <NUM>. The cause predictor <NUM> employs XAI techniques to extract information regarding how and why the cause <NUM> is selected from the plurality of causes <NUM>. The explanation <NUM> can be generated by employing tools such as layer and filter visualizations generated by the CNN. In an example, the particular portions of the images <NUM> and the specific pixels within the images <NUM> that enabled the sub-models <NUM> of the cause prediction model <NUM> to arrive at the cause <NUM> can be included in the explanation <NUM>. The output <NUM> from the cause predictor <NUM> therefore not only includes textual data referring to the cause <NUM> of the damage but also includes an explanation in the image format pertaining to the portions and pixels of the images <NUM> leading the cause prediction model <NUM> to arrive at the cause <NUM> and the outputs of the various layers/filters from the sub-models <NUM>.

The images <NUM> are also provided to the parts identifier <NUM> for image segmentation and for identification of the various parts of the damaged object from the images <NUM>. The parts identifier <NUM> also includes an ML parts identification model <NUM> for identifying and labelling the various damaged, non-damaged and repairable parts of the damaged object from the images <NUM>. In an example, the parts identification model <NUM> can include a faster RCNN that is trained via labeled data for the identification of the various parts. The damaged parts are those parts which are identified as both requiring replacement as well as repairable parts which can be fixed without the need for replacements. The parts identifier <NUM> can also be configured to produce a damage assessment of the damaged object in terms of an overall percentage and in terms of damage percentage for individual parts of the damaged object. The identification of the damaged, non-damaged, repairable and replacement parts <NUM> enables the damage detection and estimation system <NUM> to automatically assess the cost of fixing the damaged object. The part <NUM> also serves to explain visually how images of the repaired parts are similar to each other while being different from examples of other classes, like replacement.

The cost estimator <NUM> accesses data regarding damaged, non-damaged, repairable and replacement parts in order to generate a cost estimation for repairing the damaged object. In an example, the cost estimator <NUM> can be connected to a local database which stores the costs associated with repairing or replacing the various parts of the damaged object. In an example, the cost estimator <NUM> can be connected to a third-party cost estimation provider such as an online tool that provides a more dynamic cost estimate <NUM> for the repairs. In an example, custom Python scripts can be employed to call third-party data sources such as OEMs, the manufacturers of the object and/or authenticated dealers of the replacement parts to retrieve the total cost of restoring the damaged object.

The final output from the damage detection and estimation system <NUM> therefore includes the output <NUM> which details the cause <NUM> of damage and the explanation <NUM> for the cause <NUM>, automatically identified damaged parts requiring replacements and repairable parts <NUM> as well as the cost estimate <NUM> for repairing the damaged object.

Finally, the models trainer <NUM> can include or may access different types of training data required to train the various ML models within the damage detection and estimation system <NUM> including the sub-models <NUM> in the cause prediction model <NUM> and the parts identification model <NUM>. Training data sets <NUM>, <NUM> with labeled images can be used for supervised training of the ML models. The training data <NUM> can store sub-sets of images of objects belonging to the same object category such as the damaged object captured in the images <NUM> that are damaged due to various causes. Each of the sub-sets can be used to train a corresponding one of the sub-models <NUM> in identifying a cause of damage for one particular portion of the damaged object. The images for the training data sets <NUM>, <NUM> can be provided to a software, such as Labelimg which is a graphical image annotation tool and which can label object bounding boxes in images, where the images are manually annotated so that the images map to a specific label name and coordinates into an XML file (e.g., <labelname>fender</labelname>, <xmin><NUM></xmin>, etc.) The XML file is associated with the respective image where the label and the four coordinate points are appended to form a box or a rectangle at the specific portion of the image as detailed by the coordinates. The XML file and the image are used for training the ML models that learn the parameters and recognize on the new images and maps the trained weights learnt from the training images to detect new images.

For example, if the damaged object in the images <NUM> is a car damaged due to a hailstorm the damage detection and estimation system <NUM> is trained to identify the cause of damage on the training data <NUM> which includes images of different parts of the cars damaged due to various reasons such as hailstorms, natural perils, collisions, etc. The training data <NUM> can include a subset of images of front portions of different cars damaged due to one of the causes, e.g., a hailstorm. Therefore the subset of images can be used to train a sub-model to identify the front portion of a car damaged due to a hail storm. Another sub-set including images of rear portions of different cars damaged due to collisions can be employed to train a sub-model to identify rear portion of the car when it is damaged due to a collision. For each cause, the training data <NUM> can include a plurality of sub-sets of images corresponding to different portions of an object damaged due to that cause. Furthermore, it was observed that the accuracy of the cause prediction model <NUM> improved when B/W images were used for training as opposed to colored images. Hence, B/W images of different parts of the cars which are damaged due to various causes that form the plurality of causes <NUM> are included in the training data <NUM> for training the cause prediction model <NUM>. Furthermore, it is observed that both the precision and accuracy in identifying the cause of damage improves when an ensemble model is used as opposed to a single model. In an example, precision can be obtained as:<MAT>.

Similarly, the training data <NUM> which is used for training the parts identification model includes images of cars with their external parts explicitly labeled. The training data <NUM> can include images of cars with the external parts in different conditions with the various parts labeled to reflect the condition of that part. For example, there can be images of cars with bonnets that are not damaged, bonnets that are damaged and need replacements and bonnets that can be repaired. For each labeled part of the object, various images of the part in different conditions need to be included in the training data <NUM> in order to train the parts identification model <NUM> to provide an output not only recognizing the part but also identifying a condition of the part.

The models trainer <NUM> can be configured to apportion part of the training data set for testing in order to test the accuracy of the trained models. Generally <NUM>% of the data set may be used for training the models while <NUM>% may be used for testing the trained models. Various factors were experimented with as detailed herein in order to improve the accuracy of the ML models. In an example, initial hyper-parameter of <NUM> epochs was used with a batch size of <NUM> for the training data <NUM>, which yielded a model accuracy of <NUM>% on the test data set. The number of epochs is a hyper-parameter that defines the number of times that the model will work through the entire training data set. Similarly, with <NUM> epoch, the parts identification model <NUM> was only able to detect some parts of the damaged object e.g., a bumper of the car with the model accuracy of around <NUM>%. When the epoch was raised to <NUM> epoch, the loss came down and the model accuracy rose to <NUM>-<NUM>% range. The ML models that are able to produce results with the desired accuracy can be launched within the automatic damage detection and estimation system <NUM>.

The different component parts of the damage detection and estimation system <NUM> can be designed as separate modules that can be individual operated using micro and lightweight web framework such as Flask®. For example, the damage detection and estimation system <NUM> may only include the cause predictor <NUM> which outputs the causes and the reasons for selecting the causes for various damages. In another example, the damage detection and estimation system <NUM> can be operated as a whole to include the various component parts for predicting the causes and for producing the estimates for fixing the damaged objects as detailed herein.

While the automatic damage detection and estimation system <NUM> is described above with respect to objects associated with a single object category, it can be appreciated that similar automatic damage detection and estimation systems can be developed for different object categories. For example, different object categories pertaining to machinery, buildings, materials, etc. can be identified. Each object category can have a corresponding plurality of causes for damage to objects of that category for selection. In fact, there can be sub-categories within a given object category with their corresponding plurality of damage causes. When the images are initially received, object identification techniques as detailed herein can be adopted to classify the images into a specific object category and damage causes can be selected from the corresponding plurality of causes using an ensemble cause prediction model (including sub-models) trained for that object category in accordance with the training methodologies disclosed herein. Similarly, various parts of the damaged object and their states can also be identified using a parts identification model trained for the specific object category and cost estimation for restoration/repairs can be retrieved from the corresponding data sources which include the relevant information.

<FIG> shows a block diagram of the cause predictor <NUM> in accordance with some examples. The cause predictor <NUM> includes an image preprocessor <NUM>, the cause prediction model <NUM> and an XAI output generator <NUM>. The analysis of the images <NUM> for identification of a cause from the plurality of causes <NUM> pertains to a multi-class classification problem wherein the cause prediction model <NUM> classifies the images <NUM> into one of the plurality of classes/causes. Examples are discussed herein below referring to damage to vehicles due to various causes. However, it can be appreciated that the ML models and training methodologies discussed herein are applicable to identifying and estimating damages to various objects due to different causes/classes.

The image preprocessor <NUM> is configured to determine if the images <NUM> are monochrome, grayscale or B/W images or if the images <NUM> are colored images based on the RGB values of the pixels. If the images <NUM> are colored images, the image preprocessor <NUM> converts the colored images to B/W images <NUM> since using B/W images increases the accuracy of the model prediction. For example, it is determined that the cause prediction model <NUM> had an accuracy of about <NUM>% with colored images but the accuracy increased to almost <NUM>% when monochrome, grayscale or B/W images were used. Generally, grayscale images have equal red, green and blue values. Filters or other tools can be applied to the images to convert the RGB values for each pixel in order to obtain the B/W images.

The B/W images <NUM> are accessed by the cause prediction model <NUM> for determining the cause <NUM> for damage from the plurality of causes. Alternately, the cause prediction model <NUM> can classify the images <NUM> into one of classes pertaining to the plurality of causes <NUM>. In an example the images <NUM> can include a damaged vehicle and the plurality of causes <NUM> which are applicable can include collision, hailstorm or natural peril (such as hurricanes, floods, etc.). The sub-models <NUM> that are comprised within the cause prediction model <NUM> are each trained to identify one portion of the vehicle damaged due to one of the causes. Accordingly, if there are 'm' vehicle portions or parts to be identified (where m is a natural number), the cause prediction model <NUM> can have m sub-models that cover the entire external surface of the object. It may be noted that three causes are used herein for the plurality of causes <NUM> for illustration purposes only and that the cause prediction model <NUM> can be trained to identify a cause from greater or lesser number of causes as applicable. Similarly, other instances of the cause prediction models can be trained on other applicable causes to identify a cause of damage to other damaged objects in accordance with the examples disclosed herein.

The cause prediction model <NUM> is augmented with an XAI output generator <NUM>. The XAI output generator <NUM> employs model-specific techniques such as Grad-CAM for producing visual explanations for CNNs included in the sub-models <NUM>. Grad-CAM takes a feature map of the final convolution layer and then weighs every channel in the feature map based on the gradient of a target class with respect to the channel. Next, global average pooling across two dimensions of the class gradients follow by RELU activation are applied to obtain the visual explanation. One or more images highlighting the important regions in each of the images <NUM> that contributed to making a prediction regarding the cause <NUM> are generated by the sub-models <NUM> and thus output by the XAI output generator <NUM>. While Grad-CAM visualizations can localize relevant image regions to a reasonable degree for certain applications, they fail to show fine-grained importance like pixel-space gradient visualization methods. Therefore, an additional technique referred to as Guided Grad-CAM can be employed to generate high-resolution visualizations from one or more of the sub-models <NUM> that can show the exact pixels that were important or that contributed the most to the decision of the cause prediction model <NUM> regarding the cause <NUM>. The sub-models <NUM> therefore enable extracting local feature visualizations. The same local features are used as part of XAI and are visualized for better interpretability of decision making. Global features describe an image as a whole and can be interpreted as a particular property of the image involving all pixels, while the local features aim to detect key points within the image and describe regions around these key points. Edge detection can provide good explanations regarding the features or edges that were involved in the model decision making. The output <NUM> from the cause predictor <NUM> is generated to include the cause <NUM> of the damage as provided by the cause prediction model <NUM> and the image portions and image pixels leading the cause prediction model <NUM> to arrive at the cause <NUM> as provided by the XAI output generator <NUM>.

<FIG> shows a block diagram of the parts identifier <NUM> in accordance with the examples disclosed herein. The parts identifier <NUM> analyzes the images <NUM> using the parts identification model <NUM> which is trained via supervised learning to identify the various parts of the damaged object pictured in the images <NUM>. More particularly, the parts identification model <NUM> is trained to segment and recognize the different non-damaged, damaged and repairable parts of the damaged object in the images <NUM>. In an example, the parts identification model <NUM> includes a Faster RCNN which is an object detection model. The damaged objects such as vehicles generally tend to be complex with various external parts. Therefore, assigning labels to the external parts with image classification models can be difficult. Object detection models such as the RCNN are more appropriate to identify multiple relevant parts/objects from a single image. Moreover, object detection models provide for localization of the objects as opposed to the image classification models. In an example, Tensor Flow® object detection application programming interfaces (APIs) can be used for the parts identification. The parts identification model <NUM> therefore outputs the versions of the images <NUM> with the parts <NUM> labeled. Furthermore, the parts identification model <NUM> can also identify portions pf the images <NUM> that include the damaged portions which are output by a damaged parts extractor <NUM>. In an example, the damaged parts extractor <NUM> identifies those parts labeled as damaged parts and other parts labeled as repairable parts. A damage estimator <NUM> access the data regarding the damaged parts <NUM> in order to determine the extent of damage to the damaged object from the images <NUM>. In an example, image comparison techniques can be used to identify the extent of damage to each damaged part in terms of damage percentage. The damage estimator <NUM> can employ a ratio of the damaged parts to the total number of parts of the damaged object in order to determine the extent of damage as a percentage. The damage estimate <NUM> can therefore be generated as an infographic e.g., a pie chart to convey the damage percentage.

<FIG> shows an example of an ensemble ML model <NUM> used as the cause prediction model <NUM> trained to identify damage to a car in accordance with the disclosed examples. The ensemble ML model <NUM> includes a plurality of sub-models <NUM>. One of the images <NUM> is analyzed by each of the plurality of sub-models <NUM> that is trained to classify one of the portions of the car into one of the plurality of causes <NUM>. If the portion of the car is not damaged, then the likelihood may be insignificant for all the plurality of causes. Accordingly, the front model <NUM> outputs a likelihood regarding a cause of damage Y_F to the front portion of the car selected from the plurality of causes associated with the car category. Similarly, the right side model <NUM> outputs a likelihood regarding the cause of damage Y_RS to the right side of the car, the left side model <NUM> outputs a likelihood regarding the cause of damage to the left side of the car while the back model <NUM> outputs a likelihood regarding the cause of damage to the back portion of the car. The local feature model <NUM> enables local feature extraction. The final output <NUM> regarding the most likely cause of damage is computed as an average of all the model outputs. Model averaging is an ensemble method where the plurality of sub-models <NUM> can contribute equally to a combined prediction. In an example, the contributions of the sub-models can be weighed by the corresponding expected performances of the sub-models which can be extended via 'stacking' wherein another ML model learns a best way to combine the contributions from the different sub-models to produce output of highest accuracy.

<FIG> shows a block diagram that shows a high-level architecture of a CNN <NUM> employed for a sub-model in the ensemble of the cause prediction model <NUM> in accordance with the examples disclosed herein. It can be appreciated that the details of the CNN are discussed herein for illustrative purposes only and that other ML models can also be employed in accordance with the examples disclosed herein. CNNs are neural networks made up of neurons with learnable weights and biases wherein the architecture is designed to handle image inputs. CNNs Convolution layer <NUM> is the first layer that extracts features from the input images <NUM> (similar to the images <NUM>) and preserves the relationship between pixels by learning image features using small squares of input data. Convolution is a mathematical operation (e.g., a dot product) that takes two inputs such as the image matrix and a filter or a kernel. The convolution layer <NUM> can comprise a set of independent filters wherein each filter is independently convolved with each of the input images <NUM> to produce the corresponding feature maps <NUM>. A dot product of the input provided to each neuron with the corresponding filter is therefore obtained followed by a non-linearity. In an example, the input images may have sizes <NUM> x <NUM> x <NUM> wherein <NUM> is the number of channels since the input images are monochrome or B/W images. In the CNN <NUM>, thirty-two filters, each of <NUM> x <NUM> size may be used with stride <NUM> throughout the CNN <NUM>. In an example, a CNN having <NUM> convolution layers was unable to produce output with the required accuracy and was replaced with the CNN <NUM> having <NUM> convolution layers thereby improving the model accuracy. Conv1D which did not yield the desired accuracy was replaced with Conv2D for improving the model in terms of model design and prediction. The number of layers that provide the desired accuracy for a model can depend on the model itself and the dataset that the model is being trained on. In some examples, greater number of layers need not necessarily increase the accuracy.

In some instances when the images are too large, the number of trainable parameters need to be reduced. It is then desired to periodically introduce pooling layers between subsequent convolution layers. Pooling enables reducing the spatial size of an image. Pooling is applied independently on each depth dimension and therefore the depth of the image remains unchanged. Furthermore, pooling layers <NUM> provide for down sampling feature maps <NUM> to address sensitivity of the feature maps to locations of the features in the input images. Pooling layers <NUM> enable down sampling by summarizing the presence of features in patches of the feature maps <NUM>. A form of pooling layer generally applied is the max pooling. In an example such as the CNN <NUM>, a <NUM> x <NUM> maxPooling for <NUM> layers may be applied. The feature maps or activation maps thus obtained are unified via feature unification and fusion <NUM> wherein the <NUM>-dimensional feature maps/activation maps are stacked along the depth dimension. The CNN <NUM> can further include a Rectified Linear Unit (RELU) layer for a non-linear operation. The non-linearity is introduced which allows backpropagation of errors to have multiple layers of neurons being activated by the RELU function in the CNN <NUM> as real-world data requires the CNN <NUM> to learn non-negative linear values.

Overfitting happens when the CNN <NUM> is too customized to a given training data set that it fails with unseen data. Many methods such as adding more data, augmenting existing data or using more generalized architectures, adding regularization, etc. can be employed to mitigate overfitting. A popular regularization option includes dropout which can delete a random sample of activations (i.e., zero the output of those neurons) in training. In an example, the CNN <NUM> can include <NUM> dropout layers at <NUM> that remove a predetermined percentage of neurons in order to better generalize the CNN <NUM> so that it works well with unseen data sets.

The feature map matrix after the pooling layers <NUM> can be flattened as vector (x1, x2, x3. With the fully connected layers <NUM>, the features are combined together to create a model. Convolution layers generate 3D activation maps while the output includes a determination regarding whether or not an image belongs to a particular class (e.g., one of the plurality of causes <NUM>). The output layer has a loss function like categorical cross-entropy, to compute the error in prediction. Once the forward pass is complete the backpropagation begins to update the weight and biases for error and loss reduction. In an example, the loss function can include activation Softmax and cross-entropy loss. In an example, the loss function can be given as: <MAT>.

Eq. (<NUM>) includes a Softmax activation and a Cross-Entropy (CE) loss. The CNN is trained to output a probability over the C classes for each image. It is used for multi-class classification wherein the Target vector t is computed as a gradient of CE loss with respect to each of the CNN class score (s) where si is the score of any positive class. In Eq. (<NUM>), ti and si are the ground truth and the CNN scores for each class i in C. An activation function Softmax is applied to the scores before the CE loss is computed wherein f(si) refers to the activations.

<FIG> shows a block diagram <NUM> detailing the training of each of the plurality of sub-models <NUM> in accordance with the examples disclosed herein. The images <NUM> of front sides of different cars damaged due to various reasons are provided to the Front model <NUM> along with the corresponding cause of damage information to the Front model <NUM>. For example, the images <NUM> include bonnets of cars damaged due to collision and hailstorm. Similarly, images <NUM> of right sides of different cars damaged due to various reasons are provided along with the corresponding cause of damage information to the Right side model <NUM>. Images <NUM> of left sides of different cars damaged due to various reasons are provided along with the corresponding cause of damage information to the Left side model <NUM>. Images <NUM> of rear portions of different cars damaged due to various reasons are provided along with the corresponding cause of damage information to the Back model <NUM> while images <NUM> of local features are provided to train the local feature model <NUM>. One example of training a ML model with local features employs OpenCV edge detector. It enables the local feature model <NUM> to recognize the damaged object despite significant clutter and obstruction.

<FIG> shows a block diagram illustrating the XAI aspects of the cause prediction employing the Grad-CAM and Guided Grad CAM in accordance with the examples disclosed herein. The inputs to the XAI output generator <NUM> can include one or more of the images <NUM> and the plurality of causes <NUM>. The images <NUM> are forward propagated along path 'C' through the CNN <NUM> and task-specific computations to obtain a score for one of the plurality of causes. The gradients are set to zero for all the causes except for the desired cause which is set to <NUM>. The non-zero signal is then back-propagated along path 'B' to the rectified convolutions feature maps of interest <NUM> which are combined to compute the coarse Grad-CAM localization that include the images <NUM> with the image portions employed by the cause prediction model <NUM> for arriving at the cause <NUM>. The images <NUM> are pointwise multiplied with the guided back propagating signal to get Guided Grad-CAM visualizations <NUM> that have high-resolution and are cause-specific.

An example visualization technique includes showing the activations of the network during the forward pass along path 'C'. For ReLU networks, the activations initially tend to be relatively blobby and dense, but as the training progresses the activations usually become more sparse and localized. A drawback with this visualization is that some activation maps may be all zero for many different inputs, which can indicate "dead" filters, and can be a symptom of high learning rates. Dead filters can be avoided by using Conv/fully connected (FC) filters. Conv/FC filters are generally interpretable on the first convolutional layer which directly analyzes the raw pixel data from the input images. However, visualizations for filters deeper in the CNN can also be obtained. The second strategy is to visualize the weights. The weights are usually most interpretable on the first convolutional layer which processes the raw pixel data, but it is possible to also show the filter weights deeper in the network. The weights are useful to visualize because well-trained networks usually display smooth filters without any noisy patterns. Noisy patterns can be an indicator of a network that hasn't been trained for long enough, or possibly a very low regularization strength that may have led to overfitting.

To obtain the class-discriminative localization map, Grad-CAM computes the gradient of yc (score for class c) with respect to k feature maps Ak for of each convolutional layer corresponding to different ij. These gradients flowing back are global-average-pooled to obtain the importance weights αck: <MAT>.

Similar to CAM, Grad-CAM heat-map is a weighted combination of feature maps, but followed by a ReLU: <MAT>.

It may be appreciated that Grad-CAM has been discussed herein as one example of XAI and that other visualization techniques such as but not limited to, OpenCV saliency MAP, Keras Class Activation maps and OpenCV heat maps may also be employed to yield similar results.

<FIG> shows a block diagram <NUM> that details detecting and labeling the parts of an object e.g., the damaged object by the parts identifier <NUM> from the images <NUM> in accordance with the examples disclosed herein. The parts identifier <NUM> employs a faster RCNN that is trained via labeled data for the identification of the various parts including damaged parts, repairable parts and non-damaged parts which are intact and need no repairs or replacements. Images of some example damaged objects such as vehicles or other machinery can be complex with multiple parts. Therefore, assigning labels with image classification models can be difficult and may lead to inaccurate results. Instead, object detection models such as the faster RCNN are employed to identify multiple relevant objects (i.e., parts) from one or more of the images <NUM>. Another advantage of using object detection models versus image classification models in this instance is that the object detection models provide for localization of the objects which aids in isolating parts of the damaged object. In an example, Faster RCNN-Inception-V2-COCO can be used in the parts identifier <NUM>.

A raw image <NUM> which can include one of the images <NUM> which may include a B/W image or a colored RGB image prior to B/W conversion is analyzed to generate proposals for the regions that contain different objects i.e., the parts of the damaged object in the raw image <NUM>. To generate the region proposal networks (RPNs) <NUM> for the different object parts, a small network is slid over a convolutional feature map from the last convolutional layer. Each of the RPNs can include classifiers and regressors. The classifier of a RPN can determine the probability of a proposal having a target object (i.e., a part of the damaged object) and regressors regress the coordinates of the proposals. The output from the RPNs which include proposals or image regions that are likely to contain target objects may be of different shapes. Next, the region of interest pooling (ROIP) <NUM> is employed to reshape the regions that are output from the RPNs into fixed sizes such as squares. The proposals thus reshaped or the reshaped regions are finally fed to the fully connected layer <NUM> to obtain a final output with the various labeled parts <NUM>. The output at <NUM> can include the raw image <NUM> with the various labeled parts wherein the annotations can be saved in an attached extensible markup (. From the ROI feature vectors, a Softmax layer can be used to predict the class of the proposal or the proposed region and to also offset the values of the bounding box. In an example, the class of the proposed region may not only include the object part but also a state of the object part i.e., whether the part is damaged, repairable, replaceable and non-damaged. Once the fast RCNN model can identify the parts of the damaged object and the corresponding states, a damage percentage indicative of the extent of damage to the damaged object can be obtained as a ratio of the total damaged and defective body parts divided by the total body parts of the object. The cost estimator <NUM> provides a cost estimate for each body part that needs a replacement or a repair.

<FIG> shows a flowchart <NUM> that details a touchless method of automatically detecting damage to an object and estimating the cost of restoring the damaged object in accordance with the examples disclosed herein. The method outlined in the flowchart <NUM> is touchless as a computing device implementing the automatic damage detection and estimation system <NUM> can receive raw images such as the images <NUM> and output the likely cause of damage, the extent of damage and the cost estimation for the repair of the object. The computing device implementing the damage detection and estimation system <NUM> as described herein can include mobile devices such as a tablet device, a smartphone, etc. Hence, the damage detection and estimation system <NUM> can be implemented on edge devices, for example, as an "app". In fact, as mentioned above, the damage detection and estimation system <NUM> can be modularized using, for example, Flask® services so that certain portions of the damage detection and estimation system <NUM> may be separately installed without requiring other portions. For example, the cause predictor <NUM> can be used without the parts identifier <NUM> or vice versa. At <NUM>, the images <NUM> of the damaged object are received. For example, a user who may be at the location of the damaged object can capture the images <NUM> of the damaged object using a mobile device or other camera devices and transmit them to the damage detection and estimation system <NUM> via a communication network such as the internet. At <NUM>, the cause <NUM> of the damage is determined from the plurality of causes <NUM> using the cause prediction model <NUM>. At <NUM>, an explanation for the selection of the cause <NUM> from the plurality of causes <NUM>. The explanation is generated using techniques such as Grad-CAM and guided Grad-CAM and includes portions and pixels from the images <NUM> that enabled the cause prediction model <NUM> in selecting the cause <NUM> from the plurality of causes <NUM>.

At <NUM>, the various parts of the damaged object are identified from the images <NUM> using the parts identification model <NUM>. Furthermore, the parts identification model <NUM> can be configured to identify damaged parts that need replacement, partially damaged parts that can be repaired and parts of the damaged object that are intact. More particularly, the parts identification model <NUM> can output images of the damaged/partially damaged parts of the damaged object. At <NUM>, the extent of damage is calculated as described herein and output as a percentage. At <NUM>, the cost estimation for the restoration of the damaged object is obtained from one or more of the object manufacturers and/or parts dealers. The cause of damage, the output from the parts identification model <NUM> and the cost estimation are output by the damage detection and estimation system <NUM>.

<FIG> shows a flowchart <NUM> for determining a cause of the damage to the damaged object from the images <NUM> in accordance with an example. At <NUM>, the training data <NUM> for training the cause prediction model <NUM> for a particular object category is accessed. The training data <NUM> can include labeled images of various portions of damaged objects belonging to a particular object category that the cause prediction model <NUM> is being trained on for automatic cause determination. The training data <NUM> can include monochrome versions or B/W images of damaged objects labeled with the corresponding causes of damage from the plurality of causes <NUM>. By way of example, in an implementation it is observed that the CNNs used for sub-models within the cause prediction model <NUM> were producing a low accuracy of <NUM>% with RGB images. However, when B/W images are used, the model accuracy improved to almost <NUM>%. It was also observed that precision of the CNN model was <NUM>% with a single CNN model. However, when, ensemble model was used with Local features the precision was improved to <NUM>%. A CNN was selected as the cause prediction model <NUM> since the cause of the damage is inferred based on features selected from the entirety of each of the images <NUM>. The CNNs included in the cause prediction model <NUM> are trained on the labeled training data at <NUM> via supervised learning. In an example, the CNN models can be trained on Amazon Web Services (AWS) with GPU based process for <NUM> epoch which can significantly increase the model accuracy and generalizes the CNNs better in order to enable the CNNs to work with unseen data. Fewer epochs can lead to local maxima on the training dataset. Initial hyper-parameters of <NUM> epochs where optimizers. adma Ir = <NUM>, epsilon = None, decay = 1e-<NUM> with a batch size of <NUM> can yield an accuracy of <NUM>% on a test dataset. While different activation functions such as tan, sigmoid, etc., can be used, RELU Gridsearch computer vision (CV) was employed for the cause prediction model <NUM> and the hyper-parameters suggested by Gridsearch were chosen which resulted in a model accuracy of <NUM>% for the CNN used in the cause predictor <NUM>.

At <NUM>, the images <NUM> (B/W or colored images) of the damaged object are obtained. At <NUM>, monochrome versions or B/W versions of the images <NUM> are obtained using the image preprocessor <NUM> in case the images <NUM> are colored images. In an example, where the damage detection and estimation system <NUM> is implemented as an 'app' in an edge device such as a smartphone, the user taking the pictures of the damaged object can be instructed to capture the images/video in B/W so that the received images can be fed directly to the cause prediction model <NUM>. The B/W or monochrome images are provided to the cause prediction model <NUM> at <NUM>. The cause prediction model <NUM> determines and outputs a cause of damage for the damaged object from one of the plurality of causes <NUM> at <NUM>. As mentioned above, each of the sub-models <NUM> outputs a likelihood or a probability percentage regarding the cause of damage to the corresponding portion of the damaged object and the final output from the cause prediction model <NUM> is obtained as an average of the outputs from the sub-models <NUM>.

At <NUM>, an explanation of the selection of the cause <NUM> is generated via the various layer visualizations. The feature maps that result from applying filters to input images and feature maps that are output by prior layers in a CNN can provide insights into the internal representation that the model has of a specific input at a given point in the model. While gradient visualizations may suffice in certain situations, the filter visualizations of each of the layers in the CNN can provide an explanation of a step-by-step process of how the image features were extracted by the CNN. The layer visualizations are obtained using Keras. The layer visualizations can include at least one visualization of the final layer which helped the cause prediction model <NUM> take a decision between one of the plurality of causes <NUM>. In addition, the pixels that contributed to the decision are also obtained at <NUM> using the Guided Grad-CAM that shows the pixels that contributed the most to the selection of the cause <NUM> from the plurality of causes <NUM>. Saliency maps including monochrome images can be output as the explanation for the selection of the cause <NUM>. The portions of the images and image pixels that contributed the most to the selection of the cause <NUM> may be better seen in monochrome images as opposed to colored images. One advantage of using local features is that they may be used to recognize the object despite significant clutter and obstruction. One example of training the sub-models with Local features includes use of OpenCV edge detector.

<FIG> shows a flowchart <NUM> that details a method of identifying the various parts of the damaged object and estimating the cost of restoration in accordance with the examples disclosed herein. The method begins at <NUM> wherein training data <NUM> for training the parts identification model <NUM> for a particular object category is accessed. The training data <NUM> can include images of various damaged objects belonging to a particular object category with the parts labeled that the parts identification model <NUM> is being trained on for automatic parts identification. Not only are the parts in the images of the training data <NUM> labeled but the part labels include further qualifiers that describe whether the part is intact and needs no work, whether the part is repairable and whether the part is damaged - indicating that the part needs replacement. Referring to the example of a damaged car, a scratch on the body may be repairable while a shattered windshield requires replacement. The object images can be processed by a software tool such as 'labelimg' where the images are annotated so that they map to specific label names and co-ordinates in an XML file.

The parts identification model <NUM> is trained on the labeled training data at <NUM> via supervised learning. In an example, the parts identification model <NUM> can include object identification ML models such as a faster RCNN on Windows® Deep Learning using Amazon® Machine Images (AMI). Annotating the images with the qualifiers describing the state of a given part enables the faster RCNN to identify the state of the parts in unseen data. When trained on lower epochs, the faster RCNN can fail to detect all the parts. It was determined that training the faster RCNN model on higher epochs e.g., <NUM>,<NUM> epochs enabled the identification of object parts such as a car's external body parts with model accuracies of about <NUM>%-<NUM>%. The training images with the attached xml files are fed to the faster CNN during the training.

At <NUM>, the images <NUM> of the damaged object are obtained. The region proposal networks are generated at <NUM> for identifying the various parts and the states of the various parts of the damaged object pictured in the images <NUM>. At <NUM>, the region of interest pooling (ROIP) <NUM> is employed to reshape the output from the RPNs into fixed sizes such as squares. The reshaped proposals or regions are provided to the fully connected layer of the faster R-CNN at <NUM> which outputs the detected parts with the labels. At <NUM>, a listing of the parts that are damaged and need replacement and parts which are repairable can be generated along with the extent of damage. In an example, the extent of damage can be estimated in terms of the damage percentage and an infographic such as a pie chart showing the percentage may be generated. The costs of the repairs and replacements can be retrieved <NUM> using, for example, Python scripts from local or external databases including original manufacturers, replacement part dealers or service providers, etc. The listing of damaged parts along with the extent of damage and the costs are output at <NUM>.

<FIG> shows images generated by the XAI output generator <NUM> in accordance with the examples disclosed herein. The set of images <NUM> pertains to images of a car damaged due to hailstorm. An original image <NUM> is one example image received within a set of images of the damaged object. The images in the set are analyzed and the important regions in the image <NUM> that contributed to making a prediction that the damage was caused by a hailstorm are highlighted and output by the XAI output generator <NUM> using techniques such as Grad-CAM. The image <NUM> is an example image generated via layer visualization. In addition, a saliency map <NUM> is generated using Guided Grad-CAM which produces high-resolution visualizations that can show the exact pixels that were important or that contributed the most to the decision of the cause prediction model <NUM> regarding the cause <NUM>. The output <NUM> from the cause predictor <NUM> not only includes the cause <NUM> of the damage (which is hailstorm in this instance) and the portions and pixels of the images <NUM> leading the cause prediction model <NUM> to arrive at the cause <NUM>. Similarly, another set of images <NUM> are shown. The original image <NUM> is analyzed by the cause prediction model <NUM> to identify the cause of damage as collision. In order to output a reason or explanation for outputting collision as the cause of damage, a layer visualization <NUM> is generated to show the image portions that contribution to identifying collision as the cause of damage. Grad-CAM techniques are further applied to produce a saliency map <NUM> which highlights in B/W, the pixels that contributed to identifying collision as the cause of damage. Image <NUM>, which may be received as part of the images <NUM>, shows a car with a damaged front portion and the image <NUM> shows an output generated via edge detection where the features/edges involved in the model decision making are provided as an explanation for selection of a cause of damage to the car. Similarly, an image <NUM> of a car with a bonnet damaged due to hailstorm is shown and an explanation <NUM> showing the features that enabled decision making by a model in the selection of a cause of damage is provided.

<FIG> shows outputs from layer visualizations of the cause prediction model <NUM> in accordance with an example. At <NUM>, visualizations from the first convolutional layer with <NUM> filters are shown. The visualizations <NUM> show the correspondence between the filters and the image features captured by the filters. Similarly, visualizations <NUM> from the sixth convolutional layer of the CNN which forms the cause prediction model <NUM> are also shown. Again, the visualizations <NUM> show the correspondence between the filters and the features captured by the filters. The optimum number of visualizations to be generated can depend on the model and the dataset used for training. In an example, six convolutional layers can provide the desired accuracy for the cause prediction model <NUM>.

<FIG> shows some example outputs from different components of the automatic damage detection and estimation system <NUM>. At <NUM>, the output from the cause prediction model <NUM> classifying or identifying the cause of damage as 'collision' for the damaged car in the photos is shown. At <NUM>, the outputs from the XAI output generator <NUM> showing image portions <NUM> and specific pixels <NUM> that contributed to the selection of collision as the damage cause are shown. Furthermore, visualizations <NUM> and <NUM> are generated through edge detection when identifying the cause for damage.

At <NUM> the identification of specific damaged parts is shown. In fact, the extent of damage to each damaged part is also shown. For example, the bonnet is labeled as "damaged-bonnet: <NUM>%", the headlight is labeled as "damaged-headlight <NUM>%", bumper as "damaged-bumper: <NUM>%", etc. However, it may be noted that windshield is labeled as "windshield: <NUM>%". The percentage indicated in the labels represents the extent of the particular state of the part. Therefore, for the bonnet, bumper, headlights, etc., the corresponding percentages are indicative of the extent of damage whereas for the windshield, the percentage indicates that the windshield is <NUM>% intact or not damaged. At <NUM>, the extent of damage to the vehicle is shown as <NUM>% and a corresponding pie graph <NUM> is also displayed. At <NUM> the portions of the image received at <NUM> which include the damaged parts are shown while the table at <NUM> shows the cost estimation associated with the repair/restoration of the vehicle.

<FIG> illustrates a computer system <NUM> that may be used to implement the automatic damage detection and estimation system <NUM>. More particularly, computing machines such as desktops, laptops, smartphones, tablets and wearables which may be used to generate or access the data from the automatic damage detection and estimation system <NUM> may have the structure of the computer system <NUM>. The computer system <NUM> may include additional components not shown and that some of the process components described may be removed and/or modified. In another example, a computer system <NUM> can sit on external-cloud platforms such as Amazon Web Services, AZURE® cloud or internal corporate cloud computing clusters, or organizational computing resources, etc..

The computer system <NUM> includes processor(s) <NUM>, such as a central processing unit, ASIC or other type of processing circuit, input/output devices <NUM>, such as a display, mouse keyboard, etc., a network interface <NUM>, such as a Local Area Network (LAN), a wireless <NUM>. 11x LAN, a <NUM> or <NUM> mobile WAN or a WiMax WAN, and a computer-readable medium <NUM>. Each of these components may be operatively coupled to a bus <NUM>. The computer-readable medium <NUM> may be any suitable medium that participates in providing instructions to the processor(s) <NUM> for execution. For example, the processor-readable medium <NUM> may be non-transitory or non-volatile medium, such as a magnetic disk or solid-state non-volatile memory or volatile medium such as RAM. The instructions or modules stored on the processor-readable medium <NUM> may include machine-readable instructions <NUM> executed by the processor(s) <NUM> to perform the methods and functions of the automatic damage detection and estimation system <NUM>.

The automatic damage detection and estimation system <NUM> may be implemented as software stored on a non-transitory processor-readable medium and executed by the one or more processors <NUM>. For example, the processor-readable medium <NUM> may store an operating system <NUM>, such as MAC OS, MS WINDOWS, UNIX, or LINUX, and code <NUM> for the automatic damage detection and estimation system <NUM>. The operating system <NUM> may be multi-user, multiprocessing, multitasking, multithreading, real-time and the like. For example, during runtime, the operating system <NUM> is running and the code for the automatic damage detection and estimation system <NUM> is executed by the processor(s) <NUM>.

The computer system <NUM> may include a data storage <NUM>, which may include non-volatile data storage. The data storage <NUM> stores any data used by the automatic damage detection and estimation system <NUM>. The data storage <NUM> may be used to store the images, the visualizations that are generated, the various object categories and associated causes used by the automatic damage detection and estimation system <NUM>.

Claim 1:
An Artificial Intelligence (AI) based automatic damage detection system (<NUM>), the system comprising:
at least one processor;
a non-transitory processor readable medium storing machine-readable instructions that cause the processor to:
receive images (<NUM>) of a damaged object associated with an object category;
provide monochrome versions (<NUM>) of the images to an ensemble machine learning ML cause prediction model (<NUM>) trained for the object category, the ML cause prediction model trained to identify a cause of damage for the damaged object, and the cause of damage determined from a plurality of causes (<NUM>), where the ML cause prediction model includes a plurality of sub-models (<NUM>), where each sub-model identifies a cause of damage to a corresponding part of the damaged object;
identify the cause (<NUM>) of damage to the damaged object from the plurality of causes based on the monochrome versions of the images, the identifying performed according to the cause prediction model;
obtain an explanation (<NUM>) for the identification of the cause, the explanation obtained from the plurality of causes, where the explanation includes portions and pixels of the images that enabled the cause prediction model to identify the cause from the plurality of causes, and the explanation is obtained from the cause prediction model; and
provide the cause of damage and the explanation for selection of the cause as an output (<NUM>) from the cause prediction model, where the output from the cause prediction model includes an average of outputs from the plurality of sub-models.