This disclosure relates generally to complaint management, and more particularly to a system and method for automatically managing backlog complaints.
BACKGROUND
[002] Generally, a device or an equipment manufacturer follows a stringent policy to process complaints. The complaints need to be processed in a specific period of time for remediation. Further, there are various sources of the complaints such as vendors, patients, hospitals, attorneys, retailers, resellers, and the like. Therefore, the device manufacturer has a responsibility to pay utmost attention to all the complaints for providing a meaningful resolution to the complaints and report any critical issues (if occur) to governing authorities. However, it becomes difficult for the device manufacturer when the complaints are received in an unstructured format (i.e., when formats are not predefined), and from more than one channel (for example, a phone, an email, forms, chat, and the like).
[003] Moreover, each of the complaints has its own lifecycle including intake, evaluation, investigation, Medical Data Reporting (MDR), closure, and the like. Therefore, a set of business rules must be followed at different stages of complaint remediation.
[004] Therefore, there is a need to develop a system and method that may automatically process and manage the backlog complaints.
SUMMARY
[005] In an embodiment, a method for automatically managing a plurality of backlog complaints related to products is disclosed. The method may include extracting backlog data associated with the products from a database. It should be noted that the backlog data may correspond to a plurality of backlog complaints associated with one or more of the products. The method may further include generating annotations for each of the plurality of complaints to classify each of the backlog complaints into one or more categories based on the annotations and similarity between the backlog complaints. Further, the annotations may be appended to the corresponding backlog complaints in a form of additional attributes, or as an independent attached file. The method may further include processing a set of work instructions against each of a plurality of values corresponding to a plurality of actionable attributes from the additional attributes of the complaints. The method may further include updating one or more of the plurality of values corresponding to annotations associated with the raw complaint.
[006] Further, updating the one or more of the plurality of values corresponding to annotations associated with the raw complaint may include determining a percentage deviation for each of the one or more of the plurality of values corresponding to annotations. It should be noted that the percentage deviation may be determined by comparing each of annotations of the raw complaint against the annotations of similar complaints. The updating process may further include validating the one or more of the plurality of values corresponding to the annotations associated with the raw complaint based on a user’s input. The updating process may further include determining a confidence level for each of the accepted annotations associated with the raw complaints. The updating process may further include updating the one or more of the plurality of values corresponding to the annotations associated with the raw complaint based on the confidence level.
[007] In another embodiment, a system for automatically managing a plurality of backlog complaints related to products is disclosed. The system may include a processor and a memory which stores a plurality of instructions. The plurality of instructions, upon execution by the processor, may cause the processor to extract backlog data associated with the products from a database. It should be noted that the backlog data may correspond to a plurality of backlog complaints associated with one or more of the products. The plurality of instructions may further cause the processor to generate annotations for each of the plurality of complaints to classify each of the backlog complaints into one or more categories based on the annotations and similarity between the backlog complaints. Further, the annotations may be appended to the corresponding backlog complaints in a form of additional attributes, or as an independent attached file. The plurality of instructions may further cause the processor to process a set of work instructions against each of a plurality of values corresponding to a plurality of actionable attributes from the additional attributes of the complaints. The plurality of instructions may further cause the processor to update one or more of the plurality of values corresponding to annotations associated with the raw complaint.
[008] The one or more of the plurality of values may be updated by determining a percentage deviation for each of the one or more of the plurality of values corresponding to annotations. Further It should be noted that the percentage deviation may be determined by comparing each of annotations of the raw complaint against the annotations of similar complaints, the one or more of the plurality of values may be updated by validating the one or more of the plurality of values corresponding to the annotations associated with the raw complaint based on a user’s input, determining a confidence level for each of accepted annotations associated with the raw complaints, and updating the one or more of the plurality of values corresponding to the annotations associated with the raw complaint based on the confidence level.
[009] It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the invention, as claimed.
BRIEF DESCRIPTION OF THE DRAWINGS
[010] The accompanying drawings, which are incorporated in and constitute a part of this disclosure, illustrate exemplary embodiments and, together with the description, serve to explain the disclosed principles.
[011] FIG. 1 illustrates a block diagram of an exemplary system in a network environment for automatically managing a plurality of backlog complaints related to products, in accordance with an embodiment of the present disclosure.
[012] FIG. 2 illustrates a block diagram of a system for automatically managing plurality of backlog complaints related to products, in accordance with an embodiment of the present disclosure.
[013] FIG. 3 illustrates a flowchart of a method for automatically managing a plurality of backlog complaints related to products, in accordance with an embodiment of the present disclosure.
[014] FIG. 4 is a block diagram of an exemplary computer system for implementing embodiments consistent with the present disclosure.
DETAILED DESCRIPTION
[015] The following description is presented to enable a person of ordinary skill in the art to make and use the invention and is provided in the context of particular applications and their requirements. Various modifications to the embodiments will be readily apparent to those skilled in the art, and the generic principles defined herein may be applied to other embodiments and applications without departing from the spirit and scope of the invention. Moreover, in the following description, numerous details are set forth for the purpose of explanation. However, one of ordinary skill in the art will realize that the invention might be practiced without the use of these specific details. In other instances, well-known structures and devices are shown in block diagram form in order not to obscure the description of the invention with unnecessary detail. Thus, the invention is not intended to be limited to the embodiments shown but is to be accorded the widest scope consistent with the principles and features disclosed herein.
[016] While the invention is described in terms of particular examples and illustrative figures, those of ordinary skill in the art will recognize that the invention is not limited to the examples or figures described. Those skilled in the art will recognize that the operations of the various embodiments may be implemented using hardware, software, firmware, or combinations thereof, as appropriate. For example, some processes can be carried out using processors or other digital circuitry under the control of software, firmware, or hard-wired logic. (The term “logic” herein refers to fixed hardware, programmable logic and/or an appropriate combination thereof, as would be recognized by one skilled in the art to carry out the recited functions.) Software and firmware can be stored on computer-readable storage media. Some other processes can be implemented using analog circuitry, as is well known to one of ordinary skill in the art. Additionally, memory or other storage, as well as communication components, may be employed in embodiments of the invention.
[017] Referring now to FIG. 1, a block diagram of an exemplary system 100 for automatically managing a plurality of backlog complaints related to products is illustrated, in accordance with an embodiment of the present disclosure. The system 100 may include a backlog reduction device 102. The backlog reduction device 102 may process backlog complaints parallelly using automation techniques. For example, by complaint qualification and data validation/verification, automated follow-ups, remedial action suggestions, and leveraging past validations on similar complaints at various stages of complaints processing. Thus, the backlog reduction device 102 may fasten the process of complaint remediation. This is further explained in detail in conjunction with FIGs. 2-4.
[018] Examples of the backlog reduction device 102 may include, but are not limited to, a server, a desktop, a laptop, a notebook, a tablet, a smartphone, a mobile phone, an application server, or the like. The backlog reduction device 102 may further include a processor 104, and a memory 106. The backlog reduction device 102 may be coupled to a database 110 via a communication network 108. The backlog reduction device 102 may also include a display (not shown in FIG.1). The display may further include a user interface. A user, or an administrator may interact with the backlog device 102 and vice versa through the display. By way of an example, the display may be used to display results of analysis performed by the data backlog reduction device 102, to the user. By way of another example, the user interface may be used by the user to provide inputs to the backlog reduction device 102. Thus, for example, in some embodiments, the backlog reduction device 102 may receive input from the user or administrator to validate one or more of values corresponding to annotations associated with a raw complaint via the user interface. Further, for example, in some embodiments, the backlog reduction device 102 may render results to the user/administrator via the user interface.
[019] By way of an example, the user/administrator may interact with the backlog reduction device 102 via the user interface, where the user or the administrator may get access to complaint details. In some embodiments, the user/administrator may also have access to the various artifacts like device history and lookup data, where the complaints are processed.
[020] The processor 104 may include suitable logic, circuitry, interfaces, and/or code that may be configured to automatically manage a plurality of backlog complaints related to products. The processor 104 may be implemented based on a number of processor technologies, which may be known to one ordinarily skilled in the art. Examples of implementations of the processor 104 may include a Graphics Processing Unit (GPU), a Reduced Instruction Set Computing (RISC) processor, an Application-Specific Integrated Circuit (ASIC) processor, a Complex Instruction Set Computing (CISC) processor, a microcontroller, Artificial Intelligence (AI) accelerator chips, a co-processor, a central processing unit (CPU), and/or a combination thereof.
[021] The memory 106 may store instructions that, when executed by the processor 104, may cause the processor 104 to manage the plurality of backlog complaints related to the products, in accordance with some embodiments. As will be described in greater detail in conjunction with FIG. 2 to FIG. 4, in order to manage the plurality of backlog complaints, the processor 104 in conjunction with the memory 106 may perform various functions including backlog data extraction, annotation generation, processing work instructions, updating one or more of the plurality of values corresponding to annotations, percentage deviation determination, validation of values corresponding to the annotations, and the like.
[022] The memory 106 may also store various data (for example, backlog data, backlog complaints, annotations, work instructions, values corresponding to annotations, attributes, and the like) that may be captured, processed, and/or required by the backlog reduction device 102. The memory 106 may be a non-volatile memory or a volatile memory. Examples of non-volatile memory may include, but are not limited to, a flash memory, a Read-Only Memory (ROM), a Programmable ROM (PROM), Erasable PROM (EPROM), and Electrically EPROM (EEPROM) memory. Examples of volatile memory may include, but are not limited to, Dynamic Random-Access Memory (DRAM), and Static Random-Access memory (SRAM). The memory 106 may also store various data that may be captured, processed, and/or required by the system 100.
[023] In some embodiments, the backlog reduction device 102 may include a computer system such as a desktop computer, notebook or laptop computer, netbook, a tablet computer, an e-book reader, a GPS device, a camera, a personal digital assistant (PDA), a handheld electronic device, a cellular telephone, a smartphone, an augmented/virtual reality device, another suitable electronic device, or any suitable combination thereof and may also include a web browser, such as MICROSOFT INTERNET EXPLORER, GOOGLE CHROME or MOZILLA FIREFOX, and may have one or more add-ons, plug-ins, or other extensions, such as TOOLBAR or YAHOO TOOLBAR.
[024] The communication network 108 may include a communication medium through which the backlog reduction device 102 may communicate with other devices or databases. Examples of the communication network 108 may include, but are not limited to, Internet, a cloud network, a Wireless Fidelity (Wi-Fi) network, a Personal Area Network (PAN), a Local Area Network (LAN), or a Metropolitan Area Network (MAN). Various devices in the system 100 may be configured to connect to the communication network 108, in accordance with various wired and wireless communication protocols. Examples of such wired and wireless communication protocols may include, but are not limited to, a Transmission Control Protocol and Internet Protocol (TCP/IP), User Datagram Protocol (UDP), Hypertext Transfer Protocol (HTTP), File Transfer Protocol (FTP), Zig Bee, EDGE, IEEE 802.11, light fidelity(Li-Fi), 802.16, IEEE 802.11s, IEEE 802.11g, multi-hop communication, wireless access point (AP), device to device communication, cellular communication protocols, and Bluetooth (BT) communication protocols.
[025] The database 110 may include suitable logic, circuitry, and/or interfaces that may be configured to store program instructions executable by the processor 104, operating systems, and/or application-specific information, such as logs and application-specific databases. The database 110 may include a computer-readable storage media for carrying or having computer-executable instructions or data structures stored thereon. Such computer-readable storage media may include any available media that may be accessed by a general-purpose or special-purpose computer, such as the processor 104.
[026] By way of an example, and not limitation, such computer-readable storage media may include tangible or non-transitory computer-readable storage media including, but not limited to, Compact Disc Read-Only Memory (CD-ROM) or other optical disk storage, magnetic disk storage, or other magnetic storage devices (e.g., Hard-Disk Drive (HDD)), flash memory devices (e.g., Solid State Drive (SSD), Secure Digital (SD) card, other solid-state memory devices), or any other storage medium which may be used to carry or store particular program code in the form of computer-executable instructions or data structures and which may be accessed by a general-purpose or special-purpose computer. Combinations of the above may also be included within the scope of computer-readable storage media.
[027] Computer-executable instructions may include, for example, instructions and data configured to cause the processor 104 to perform a certain operation or a set of operations associated with the backlog reduction device 102. The functions or operations executed by the backlog reduction device 102 may be performed by the processor 104. In accordance with an embodiment, additionally, or alternatively, the operations of the processor 104 are performed by various modules.
[028] Referring now to FIG. 2, a system 200 for automatically managing a plurality of backlog complaints 202a related to products is illustrated, in accordance with an embodiment of the present disclosure. FIG. 2 is explained in conjunction with FIG. 1. The system 200 includes the backlog reduction device 102, complaint sources 202, and a complaint processing system 204. In an embodiment, the plurality of backlog complaints 202a may be received from one or more of the complaint sources 202. The complaint sources 202 may include, but are not limited to, vendors, patients, hospitals, attorneys, retailers, resellers, and the like.
[029] Further, a user may access the complaint processing system 204 to get access to an assigned complaint from a pool of backlog complaints. In some embodiments, the user may understand complaint details by reviewing multiple attributes associated with the complaint. Examples of the attributes may include a type of complaint, any serious injury, any death occurred, priority/severity of the complaint, and the like.
[030] Furthermore, an input received from a customer may be a complaint or feedback. If the input is classified as the complaint, it may be processed as per work instructions set by a manufacturer. Furthermore, the processed complaint may be validated and updated back to the complaint processing system 204 keeping the audit trail and data integrity intact.
[031] In an embodiment, the backlog reduction device 102 may include a data extraction module 206, a classification module 208, a processing module 210, an execution module 212, and a moderation module 214. Further, in some embodiments, the backlog reduction device 102 may also include a datastore (not shown in FIG. 2) to store various data and intermediate results generated by the backlog reduction device 102.
[032] The data extraction module 206 may be configured to extract backlog data associated with the products from a database (for example, the database 110). The backlog data may correspond to the plurality of backlog complaints 202a associated with one or more of the products. In other words, one or more backlog complaints may be extracted by the data extraction module 206 from a pool of open complaints or tickets stored in the database. In some embodiments, the backlog data may be extracted by the data extraction module 206 using a database replication of the source database system preferably a complaint processing system using a specific query. In another embodiment, the backlog data may be extracted from the database by using a screen scraping powered by a Robotic Process Automation (RPA). For example, a user may extract screen display data from a specific user interface (UI) element or documents using screen scraper tools like Shell scripts. The UI may include a data output device and one or more data input devices. The data input devices may include but are not limited to, combinations of one or more keypads, keyboards, mouse devices, touch screens that accept gestures, microphones, voice or speech recognition devices, and any other suitable devices.
[033] In an embodiment, the backlog data may be extracted from the database by using browser extensions, based on requirements, in an attended manner. In another embodiment, the backlog data may be extracted by using a data pump export program for unloading data and metadata into a set of dump files. The set of dump files may be imported by data pump import utility on a same or another database system. The data extraction module 206 may be further configured to push each of the complaints after closure back to the complaint processing system 204. Further, the data extraction module 204 may be communicatively coupled to the classification module 208.
[034] The classification module 208 may be configured to classify each of the plurality of backlog complaints 202a into one or more categories. In some embodiments, the classification module 208 may further include an annotation module (not shown in FIG. 2). In some other embodiments, the classification module 208 may be connected to the annotation module. The annotation module may generate annotation for each of the plurality of backlog complaints. Further, based on the annotations and similarity between the backlog complaints, the classification module 208 may perform its operation. In some embodiments, the annotations may be appended to the corresponding backlog complaints in a form of additional attributes, or as an independent attached file.
[035] The classification module 208 may be further connected to a clustering module (not shown in FIG. 2) for generating one or more clusters of the backlog complaints. To generate the one or more clusters, clustering module 208 may use at least one of a tokenization technique, a vectorization technique, and a cosine similarity technique. For example, tokenization technique may be used to create Term Frequency and Inverse Term Frequency (TF-IDF). By way of another example, vectorization technique may be used to find similarity between the complaints. Further, in some embodiments, a same Unique Identity may be assigned to complaints of a same category. Further, the classification module 208 may process its output to the processing module 210.
[036] An output generated by the annotation module for an exemplary backlog complaint is given below:
{
"complaintNo": "XYZ1111",
"DeviceID”: "Dev0001",
"ComplaintType”: "Type1",
"Region”: "Region1",
"SimilarClosedComplaints (5)” : ["AAAAAA", "BBBBBB", "CCCCCC", "DDDDDD", "EEEEEE"],
"DeviationPercent": “TO BE ADDED”
}
[037] In this example, a complaint may be assigned with a reference number “XYZ1111”. The auto-generated device ID for the complaint is "Dev0001”. Further complaint type “Type 1” is an auto-generated device ID that may define a cluster to which the complaint belongs. The region in the above example is “Region 1”. In some embodiments, the complaint clusters need to be segregated based on the region of the complaint as the work instructions may vary. Further, "AAAAAA", "BBBBBB", "CCCCCC", "DDDDDD", and "EEEEEE" are closed similar complaints. In some embodiments, the closed complaints which are similar to a current complaint may be leveraged to provide aid to the user to make decisions.
[038] The processing module 210 may be configured to process a set of work instructions against each of a plurality of values corresponding to a plurality of actionable attributes from the additional attributes of the complaints. In other words, the processing module 210 may onboard the set of work instructions against actionable attributes in a backlog complaint to generate an executable code that may automate the work instructions. The executable code may be generated by converting each actionable attribute into executable code. For example, if a work instruction for “Attribute1” is “Attribtue1 needs to be represented in a proper case”, then an equivalent executable code may be generated by the processing module 210. The executable code for the “Attribute 1” may take a value corresponding to “Attribute1” and convert the value into a proper case. So, each actionable attribute may have an equivalent executable code. Therefore, executable codes may be mapped against each attribute and stored either in the data store or flat file.
[039] For example, the on-boarded executable work instructions as per the type of backlog complaint is given below:
{
"complaintType" : "Type1"
"attribute1" : "convertToProper(valueofattribute1)",
"attribute2":"getEquivalentMappingValueFromDeviceHistory(valueOfattribute2)",
"attribute3" : "formatDataAsPerWI(valueOfAttribute3),
"...." : "....",
"attributeN-1:"workInstructionforNminus1(valueOfAttributeNminus1)",
"attributeN" : "workInstructionforN(valueOfAttributeN)"
}
[040] The processing module 210 may be further configured to update a percentage deviation in the annotation by comparing the processed values. The percentage deviation is determined by comparing an actual value with expected value of similar closed complaints. The processing module 210 may be communicatively coupled to the execution module 212.
[041] The execution module 212 may be configured to pick raw complaints and read annotations of the raw complains to identify their complaint types. A raw complaint may be an unprocessed or an open complaint. The execution module 212 may further be configured to pull the executable work instructions as per the provided complaint type. The execution module 208 may further be configured to execute the executable work instructions against the value of each actionable attribute to process the complaint. In an embodiment, the output of the execution module 212 may be given as:
{
"complaintType" : "Type1",
"attribute1" : {"rawvalue" : "attributevalue1",
"processedvalue" : "processedattributevalue1"},
"attribute2" : {"rawvalue" : "attributevalue1",
"processedvalue" : "processedattributevalue1"},
.....
......
"attributeNminus1" : {"rawvalue" : "attributevalueNminus1",
"processedvalue" : "processedattributevalueNminus1"},
"attributeN" : {"rawvalue" : "attributevalueN",
"processedvalue" : "processedattributevalueN"}
}
[042] The moderation module 214 may be configured to add a confidence level against each accepted attribute within the same complaint type. The confidence level may represent a success factor of each processed complaint. Therefore, attributes rejected by other users within the same complaint type may receive more attention as other attributes have already been validated by other users who are working the complaints belonging to the same complaint type.
[043] Extraction, classification, and processing of the backlog complaints may be referred to as intake. The processing of the backlog complaints may be repeated for each stage of a complaint lifecycle before it is validated and closed. After the intake of the backlog complaints, the backlog complaints may be moved to a next stage of the complaint lifecycle. Processing of the backlog complaints may depend on a type of an equipment or a device as well as manufacturer's work instructions. It should be noted that different users may use same equipment. However, each user may report a complaint regardless of others experiencing same problem/issue/complaint as they may be unaware of others' usage. Therefore, each complaint may be independent and unrelated to each other. In most of the cases, this disconnection of complaints persists. The backlog reduction device 102 may overcome this disadvantage by reading the backlog complaints in advance when the complaints are lying in as backlog and clustering all similar looking complaints. Thereafter, the complaints may be processed further outside the complaint processing system 204 using pre-compiled rules for validation. Further, updated complaints may be processed back to the complaint processing system 204 keeping the audit trail and data integrity intact. Hence, the system 100 and associated backlog reduction device 102 may reduce time taken to process the complaints and backlog.
[044] It should be noted that the system 100 and associated backlog reduction device 102 may be implemented in programmable hardware devices such as programmable gate arrays, programmable array logic, programmable logic devices, or the like. Alternatively, the system 100 and backlog reduction device 102 may be implemented in software for execution by various types of processors. An identified engine/module of executable code may, for instance, include one or more physical or logical blocks of computer instructions which may, for instance, be organized as an object, module, procedure, function, or other construct. Nevertheless, the executables of an identified engine/module need not be physically located together but may include disparate instructions stored in different locations which, when joined logically together, comprise the identified engine/module and achieve the stated purpose of the identified engine/module. Indeed, an engine or a module of executable code may be a single instruction, or many instructions, and may even be distributed over several different code segments, among different applications, and across several memory devices.
[045] As will be appreciated by one skilled in the art, a variety of processes may be employed for automatically managing a plurality of backlog complaints related to products. For example, the exemplary system 100 and associated backlog reduction device 102 may manage a plurality of backlog complaints, by the process discussed herein. In particular, as will be appreciated by those of ordinary skill in the art, control logic and/or automated routines for performing the techniques and steps described herein may be implemented by the system 100 and the associated backlog reduction device 102 either by hardware, software, or combinations of hardware and software. For example, suitable code may be accessed and executed by the one or more processors the backlog reduction device 102 to perform some or all of the techniques described herein. Similarly, application specific integrated circuits (ASICs) configured to perform some or all the processes described herein may be included in the one or more processors of the backlog reduction device 102.
[046] Referring now to FIG. 3, a flowchart of the method 300 for automatically managing a plurality of backlog complaints related to products is illustrated, in accordance with an embodiment. Each step of the method 300 may be executed by various modules of the backlog reduction device 102. FIG. 3 is explained in conjunction with FIGs. 1-2.
[047] At step 302, backlog data associated with the products may be extracted from a database using the data extraction module 206. It should be noted that the backlog data may correspond to a plurality of backlog complaints associated with one or more of the products. The backlog data may be extracted by using at least one of a database replication of the source system, a Robotic process automation (RPA) to pull open complaint details using screen scrapping, browser extensions, and export data dump. Further, in some embodiments, the backlog complaints may be provided by one or more customers. The backlog complaints may include at least one of an unstructured complaint, a semi-structured complaint, and/or a structured complaint.
[048] At step 304, annotations for each of the plurality of complaints may be generated using the annotation module associated with the classification module 208. Further, the annotations may be used to classify each of the plurality of backlog complaints into one or more categories. In other words, based on the annotations and similarities between the backlog complaints, each of the backlog complaints may be classified into one or more categories. As a result, one or more clusters of the backlog complaints may be generated. The one or more clusters may be generated based on at least one of a tokenization technique, a vectorization technique, and a cosine similarity technique. Further, it should be noted that the annotations may be appended to the corresponding backlog complaints in the form of additional attributes, or as an independent attached file. In some embodiments, a same Unique Identity may be assigned to complaints of same category.
[049] In an embodiment, the annotation generation may include reading the backlog complaints to generate clusters of the backlog complaints based on types of the backlog complaints and the similarity of the backlog complaints. The annotation generation may further include tokenizing description of the backlog complaints along with other possible attributes identified to create a Term Frequency and Inverse Term Frequency (TF-IDF). Additionally, the annotation generation may further include vectorizing the TF-IDF to find the similarity between the backlog complaints. For example, cosine similarity or equivalent may be used to find the similarity between the backlog complaints. Moreover, the annotation generation may further include labeling the closest-looking complaints using unique IDs. Furthermore, the annotation generation may include appending closed complaints (closed in the past) and similar to a current complaint with existing vectorized form of the closed complaint to obtain similarity.
[050] In some embodiments, classification of the backlog complaints may be performed using initial understanding of a backlog complaint. Furthermore, an initial qualification may be performed to check whether it is feedback or a complaint. If it is classified as the complaint, then it may be ensured that necessary information related to the complaint is collected and sent for further processing (such as for evaluation, and investigation). If the complaint details are not fully updated/captured, a concerned team/person may be contacted to obtain additional information. During this time, the complaint may remain unprocessed, keeping the complaint count intact.
[051] At step 306, a set of work instructions may be processed against each of a plurality of values corresponding to a plurality of actionable attributes from the additional attributes of the complaints. The processing module 210 may be used to perform this step. Further, for example, the additional attributes may include detail of a customer, a date of an event, a product identity, a region, a complaint number, similar closed complaints, and a complaint type. It should be noted that the set of work instructions corresponding to each of the actionable attributes may be stored in at least one of an associated data store or a flat file.
[052] At step 308, one or more of the plurality of values corresponding to annotations associated with the raw complaint may be updated. In some embodiments, a percentage deviation may be determined for each of the one or more of the plurality of values corresponding to annotations using the processing module 210. The percentage deviation may be determined by comparing each of the annotations of the raw complaint against the annotations of similar complaints.
[053] In an embodiment, the percentage deviation may be determined by comparing an actual value with an expected value associated with a similar closed complaint. By way of an example, if there are total 100 attributes and 10 attributes out of 100 attributes have different values than expected values (when compared to similar closed complaints), then the percentage deviation is 10%. While performing validation, the percentage deviation may be used to provide additional insight to users/analysts by allowing them to look at deviated attribute values (i.e., attributes that need attention) for corrections (if necessary). Processed data may be given as:
{
"complaintType" : "Type1",
"attribute1" : {"rawvalue" : "attributevalue1",
"processedvalue" : "processedattributevalue1",
“needsattention” : false},
"attribute2" : {"rawvalue" : "attributevalue1",
"processedvalue" : "processedattributevalue1",
“needsattention” : true},

......
.....
"attributeNminus1" : {"rawvalue" : "attributevalueNminus1",
"processedvalue" : "processedattributevalueNminus1",
“needsattention” : false},
"attributeN" : {"rawvalue" : "attributevalueN".
"processedvalue" : "processedattributevalueN",
“needsattention” : false}
}
This format shows that the attribute 2 is marked as “Needs Attention” as the value or the pattern being used is different from the closed similar complaint (similar to the current complaint).
[054] In some embodiments, the one or more of the plurality of values corresponding to the annotations associated with the raw complaint may be updated based on a user’s input. A user may validate the processed backlog complaints as a part of validation (i.e., for quality check) process. In some embodiments, each processed backlog complaint may be presented to user including a raw values and processed values. Further, additional attributes may be presented to the user for the validation process.
[055] By way of an example, consider a scenario where the user agrees with a processed value. In that case the user may accept the processed value by marking the attribute “IsValidated” true. Similarly, when the user disagrees with the processed value then the user may reject the processed value by marking the same attribute false. Therefore, the processed complaint may be given as:
{
"complaintType" : "Type1",
"attribute1" : {"rawvalue" : "attributevalue1",
"processedvalue" : "processedattributevalue1",
“needsattention” : false,
“IsValidated” : true},
"attribute2" : {"rawvalue" : "attributevalue1",
"processedvalue" : "processedattributevalue1",
“needsattention” : true,
“IsValidated” : false},
......
......
"attributeNminus1" : {"rawvalue" : "attributevalueNminus1",
"processedvalue" : "processedattributevalueNminus1",
“needsattention” : false,
“IsValidated” : true },
"attributeN" : {"rawvalue" : "attributevalueN",
"processedvalue" : "processedattributevalueN",
“needsattention” : false,
“IsValidated” : true }
}
[056] Additionally, the user may be presented with an attribute which requires attention when the processed value is different from a value processed earlier for a similar complaint.
[057] In some embodiments, a confidence level may be determined for each of the accepted annotations associated with the raw complaints using the moderation module 214. Further, in some embodiments, one or more of the plurality of values corresponding to the annotations associated with the raw complaint may be updated based on the confidence level. The confidence level against each accepted attribute within the same complaint type may be added. The confidence level may represent a success factor of each processed complaint. Therefore, attributes rejected by other users within the same complaint type may receive more attention as other attributes have already been validated by other users who are working the complaints belonging to the same complaint type.
[058] By way of an example, an attribute may always be accepted by users by marking the “IsValidated” attribute to true. In that case, the success factor of the attribute may be 100%. By way of another example, an attribute may be always rejected or most of the users reject it by making the “IsValidated” attribute to false. In that case, the attribute may fall under “NeedsAttention” true category. Therefore, when a plurality of complaints belonging to a same complaint type are processed, then the attributes which requires attention may also get updated. As a result, the users may end up validating the attributes which requires attention alone rather than validating all the attributes.
[059] For example, consider a complaint 1000 attributes. Further, out of the 1000 attributes 40 attributes may be marked as “NeedAttention”. In that case, the user needs to check only 40 attributes instead of 1000 attributes, as other 60 attributes from the same complaint type are already validated by other users.
[060] The disclosed methods and systems may be implemented on a conventional or a general-purpose computer system, such as a personal computer (PC) or server computer. Referring now to FIG. 4, an exemplary computing system 400 that may be employed to implement processing functionality for various embodiments (e.g., as a SIMD device, client device, server device, one or more processors, or the like) is illustrated. Those skilled in the relevant art will also recognize how to implement the invention using other computer systems or architectures. The computing system 400 may represent, for example, a user device such as a desktop, a laptop, a mobile phone, personal entertainment device, DVR, and so on, or any other type of special or general-purpose computing device as may be desirable or appropriate for a given application or environment. The computing system 400 may include one or more processors, such as a processor 402 that may be implemented using a general or special purpose processing engine such as, for example, a microprocessor, microcontroller or other control logic. In this example, the processor 402 is connected to a bus 404 or other communication medium. In some embodiments, the processor 402 may be an Artificial Intelligence (AI) processor, which may be implemented as a Tensor Processing Unit (TPU), or a graphical processor unit, or a custom programmable solution Field-Programmable Gate Array (FPGA).
[061] The computing system 400 may also include a memory 406 (main memory), for example, Random Access Memory (RAM) or other dynamic memory, for storing information and instructions to be executed by the processor 402. The memory 406 also may be used for storing temporary variables or other intermediate information during execution of instructions to be executed by the processor 402. The computing system 400 may likewise include a read only memory (“ROM”) or other static storage device coupled to bus 404 for storing static information and instructions for the processor 402.
[062] The computing system 400 may also include a storage device 408, which may include, for example, a media drives 410 and a removable storage interface. The media drive 410 may include a drive or other mechanism to support fixed or removable storage media, such as a hard disk drive, a floppy disk drive, a magnetic tape drive, an SD card port, a USB port, a micro-USB, an optical disk drive, a CD or DVD drive (R or RW), or other removable or fixed media drive. A storage media 406 may include, for example, a hard disk, magnetic tape, flash drive, or other fixed or removable medium that is read by and written to by the media drive 420. As these examples illustrate, the storage media 412 may include a computer-readable storage medium having stored there in particular computer software or data.
[063] In alternative embodiments, the storage devices 408 may include other similar instrumentalities for allowing computer programs or other instructions or data to be loaded into the computing system 400. Such instrumentalities may include, for example, a removable storage unit 414 and a storage unit interface 416, such as a program cartridge and cartridge interface, a removable memory (for example, a flash memory or other removable memory module) and memory slot, and other removable storage units and interfaces that allow software and data to be transferred from the removable storage unit 414 to the computing system 400.
[064] The computing system 400 may also include a communications interface 418. The communications interface 418 may be used to allow software and data to be transferred between the computing system 400 and external devices. Examples of the communications interface 818 may include a network interface (such as an Ethernet or other NIC card), a communications port (such as for example, a USB port, a micro-USB port), Near field Communication (NFC), etc. Software and data transferred via the communications interface 418 are in the form of signals which may be electronic, electromagnetic, optical, or other signals capable of being received by the communications interface 418. These signals are provided to the communications interface 418 via a channel 420. The channel 420 may carry signals and may be implemented using a wireless medium, wire or cable, fiber optics, or another communications medium. Some examples of the channel 420 may include a phone line, a cellular phone link, an RF link, a Bluetooth link, a network interface, a local or wide area network, and other communications channels.
[065] The computing system 400 may further include Input/Output (I/O) devices 422. Examples may include, but are not limited to a display, keypad, microphone, audio speakers, vibrating motor, LED lights, etc. The I/O devices 422 may receive input from a user and also display an output of the computation performed by the processor 402. In this document, the terms “computer program product” and “computer-readable medium” may be used generally to refer to media such as, for example, the memory 406, the storage devices 408, the removable storage unit 414, or signal(s) on the channel 420. These and other forms of computer-readable media may be involved in providing one or more sequences of one or more instructions to the processor 402 for execution. Such instructions, generally referred to as “computer program code” (which may be grouped in the form of computer programs or other groupings), when executed, enable the computing system 400 to perform features or functions of embodiments of the present invention.
[066] In an embodiment where the elements are implemented using software, the software may be stored in a computer-readable medium and loaded into the computing system 400 using, for example, the removable storage unit 414, the media drive 410 or the communications interface 418. The control logic (in this example, software instructions or computer program code), when executed by the processor 402, causes the processor 402 to perform the functions of the invention as described herein.
[067] Various embodiments provide method and system for automatically managing a plurality of backlog complaints related to products. The disclosed system and method offer reading the complaints in advance when it is lying in as backlog and grouping all complaints that appear to be similar. The system may further provide automated processing of the complaints outside of the complaint processing system using pre-compiled rules and validating them outside the complaint processing system. The system may further provide updating the processed complaints back to the complaint processing system keeping the audit trail and data integrity intact, thereby reducing the time taken to process the complaint and reducing the backlog. The disclosed system has the potential to reduce the complaint processing MTTR (mean time to resolution).
[068] It will be appreciated that, for clarity purposes, the above description has described embodiments of the invention with reference to different functional units and processors. However, it will be apparent that any suitable distribution of functionality between different functional units, processors or domains may be used without detracting from the invention. For example, functionality illustrated to be performed by separate processors or controllers may be performed by the same processor or controller. Hence, references to specific functional units are only to be seen as references to suitable means for providing the described functionality, rather than indicative of a strict logical or physical structure or organization.
[069] Although the present invention has been described in connection with some embodiments, it is not intended to be limited to the specific form set forth herein. Rather, the scope of the present invention is limited only by the claims. Additionally, although a feature may appear to be described in connection with particular embodiments, one skilled in the art would recognize that various features of the described embodiments may be combined in accordance with the invention.
[070] Furthermore, although individually listed, a plurality of means, elements or process steps may be implemented by, for example, a single unit or processor. Additionally, although individual features may be included in different claims, these may possibly be advantageously combined, and the inclusion in different claims does not imply that a combination of features is not feasible and/or advantageous. Also, the inclusion of a feature in one category of claims does not imply a limitation to this category, but rather the feature may be equally applicable to other claim categories, as appropriate.

CLAIMS

We claim:

1. A method (300) for automatically managing a plurality of backlog complaints related to products, the method (300) comprising:
extracting (302), by a backlog reduction device 102, backlog data associated with the products from a database, wherein the backlog data corresponds to a plurality of backlog complaints associated with one or more of the products;
generating (304), by the backlog reduction device 102, annotations for each of the plurality of complaints to classify the plurality of backlog complaints into one or more categories based on the annotations and similarity between the plurality of backlog complaints, wherein generating (304) the annotations comprises appending the annotations to the corresponding backlog complaints in a form of additional attributes, or as an independent attached file;
processing (306), by the backlog reduction device 102, a set of work instructions against each of a plurality of values corresponding to a plurality of actionable attributes from the additional attributes of the complaints; and
for a raw complaint, by the backlog reduction device 102, updating (308) one or more of the plurality of values corresponding to annotations associated with the raw complaint, wherein updating (308) comprises:
updating one or more of the plurality of values corresponding to annotations associated with the raw complaint by determining a percentage deviation for each of the one or more of the plurality of values corresponding to annotations, wherein the percentage deviation is determined by comparing each of annotations of the raw complaint against the annotations of similar complaints;
validating the one or more of the plurality of values corresponding to the annotations associated with the raw complaint based on a user’s input;
determining a confidence level for each of accepted annotations associated with the raw complaints; and
updating the one or more of the plurality of values corresponding to the annotations associated with the raw complaint based on the confidence level.

2. The method (300) as claimed in claim 1, wherein the backlog data is extracted using at least one of a database replication of a source system, a specific query, a browser extension, a robotic process automation, a screen scrapping, and an export data dump.

3. The method (300) as claimed in claim 1, wherein classification comprises generating, by the backlog reduction device 102, one or more clusters of the backlog complaints, and wherein the one or more clusters are generated based on at least one of a tokenization technique, a vectorization technique, and a cosine similarity technique.

4. The method (300) as claimed in claim 1, comprising assigning a same Unique Identity to complaints of a same category.

5. The method (300) as claimed in claim 1, wherein the additional attributes comprise detail of a customer, a date of an event, a product identity, a region, a complaint number, similar closed complaints, and a complaint type, and wherein a backlog complaint provided by a customer comprises at least one of an unstructured complaint, a semi structured complaint, and a structured complaint.

6. The method (300) as claimed in claim 1, wherein the set of work instructions corresponding to each of the actionable attributes are stored in at least one of an associated data store or a flat file.

7. A system (100) for automatically managing a plurality of backlog complaints related to products, the system comprising:
a processor (104); and
a memory (106) storing a plurality of instructions, wherein the plurality of instructions, upon execution by the processor (104), cause the processor (104) to:
extract (302) backlog data associated with the products from a database, wherein the backlog data corresponds to a plurality of backlog complaints associated with one or more of the products;
generate (304) annotations for each of the plurality of complaints to classify the plurality of backlog complaints into one or more categories based on the annotations and similarity between the plurality of backlog complaints, wherein generating (304) the annotations comprises appending the annotations to the corresponding backlog complaints in a form of the additional attributes, or as an independent attached file;
process (306) a set of work instructions against each of a plurality of values corresponding to a plurality of actionable attributes from the additional attributes of the complaints; and
update (308) one or more of the plurality of values corresponding to annotations associated with the raw complaint by:
determining a percentage deviation for each of the one or more of the plurality of values corresponding to annotations, wherein the percentage deviation is determined by comparing each of annotations of the raw complaint against the annotations of similar complaints;
validating the one or more of the plurality of values corresponding to the annotations associated with the raw complaint based on a user’s input;
determining a confidence level for each of accepted annotations associated with the raw complaints; and
updating the one or more of the plurality of values corresponding to the annotations associated with the raw complaint based on the confidence level.

8. The system (100) as claimed in claim 7, wherein the processor instructions, on execution, cause the processor (104) to extract the backlog data using at least one of a database replication of a source system using a specific query, a browser extension, a robotic process automation, a screen scrapping, and an export data dump.

9. The system (100) as claimed in claim 7, wherein the processor instructions, on execution, cause the processor (104) to generate one or more clusters of the backlog complaints, and wherein the processor instructions, on execution, cause the processor to generate one or more clusters based on at least one of a tokenization technique, a vectorization technique, and a cosine similarity technique.

10. The system (100) as claimed in claim 7, wherein the processor instructions, on execution, cause the processor (104) to assign a same Unique Identity to complaints of a same category.