ASSESSING DATA RECORDS

Abstract

In one example, a method for assessing data records is disclosed. The method maps a plurality of keys to a respective plurality of the pools of records. The mapping operation may include mapping a first key to a first pool of records of a first array and mapping a second key to a second pool of records of a second array. The method applies logic rules to values of the pools of records that are in the same index or position of the first and the second array to generate a risk assessment score for a record corresponding to that index or position.

Claims

1. A method for assessing data records, the method comprising: mapping a plurality of keys to a respective plurality of the pools of records including mapping a first key to a first pool of records of a first array and mapping a second key to a second pool of records of a second array; and applying logic rules to values of the pools of records that are in the same index or position of the first and the second array to generate a risk assessment score for a record corresponding to that index or position.

2. The method of claim 1 wherein the pools of records are to compress customer record data.

3. The method of claim 2 wherein the pools of records are sets of bits of Boolean values, wherein each customer record data in a pool of records includes 1 bit for each respective customer in the record pool.

4. The method of claim 1 wherein values of the pools of records in the same index or position are for the same entity or customer record.

5. The method of claim 2 wherein the customer record data is compressed by pooling values across a plurality of customer records to form the pools of records.

6. The method of claim 1 wherein the risk assessment score for each record is based on the logical OR of values of the pools of records in the same index or position each array.

7. A system for assessing data records, the system comprising: a logic engine; a processor; and a data store to store a plurality of arrays, each array being a data pool composed of values from across a plurality of records, and each record being composed of the values in the same position or index across the plurality of arrays wherein each one of a plurality of keys is respectively mapped to each array; wherein the processor is to cause the logic engine to apply logic rules to the arrays of the pool of records to generate a risk assessment score for each record.

8. The system of claim 7 wherein the records are R.sub.1, R.sub.2, . . . R.sub.N, the arrays are A.sub.1, A.sub.2 . . . A.sub.N and, the keys are K.sub.1, K.sub.2, . . . K.sub.N.

9. The system of claim 8 wherein the arrays A.sub.1, A.sub.2 . . . A.sub.N, respectively, form a matrix defined by K.sub.1[R.sub.11, R.sub.12 . . . R.sub.1N], K.sub.2[R.sub.21, R.sub.22 . . . R.sub.2N], . . . K.sub.N[R.sub.N1, R.sub.N2 . . . R.sub.NN].

10. The system of claim 9 wherein the risk assessment score for record R.sub.1 is based on R.sub.11, R.sub.21 . . . R.sub.N1.

11. The system of claim 8 wherein values for the pool of customer records R.sub.1, R.sub.2 . . . R.sub.N are Boolean.

12. The system of claim 8 wherein the risk assessment score for each record is based on the logical OR of values of the pools of records in the same index or position of each array.

13. The system of claim 8 wherein the plurality of keys K.sub.1, K.sub.2 . . . K.sub.N are questions.

14. The system of claim 13 wherein the data pool values are responses to questions.

15. The system of claim 8 wherein the risk assessment score for each record R.sub.1, R.sub.2 . . . R.sub.N is based on the OR of each the arrays A.sub.1, A.sub.2, . . . A.sub.N.

Description

BRIEF DESCRIPTION OF THE DRAWINGS

[0002] Examples of the disclosure will be rendered by reference to specific examples which are illustrated in the appended drawings. The drawings illustrate only particular examples of the disclosure and therefore are not to be considered to be limiting of their scope. The principles here are described and explained with additional specificity and detail through the use of the accompanying drawings.

[0003] FIG. 1 illustrates a system for assessing data records to determine customer financial risks according to an example of the present disclosure.

[0004] FIG. 2 illustrates an example of a risk model and a customer pool syntax for the logic engine of FIG. 1.

[0005] FIG. 3A is an object-oriented syntax to add an amount of points to the total of a risk assessment score of a customer.

[0006] FIG. 3B illustrates a customer-pool syntax in accordance with examples of the present disclosure.

[0007] FIG. 4 is a data assessment method 400 according to examples of the present disclosure.

DETAILED DESCRIPTION

[0008] A risk assessment model and/or logic rules engine is used to conduct financial risk assessments of new and existing customers. Specifically, a risk assessment model and/or logic rules engine can be used to determine a customer's overall score, a category-specific risk score, and whether the customer is a low, medium or high financial risk customer. Many such risk assessment models often need to be updated for any number of reasons. The updates may be to account for changing geopolitical environments, or changes in risk assessment rules, or other unforeseen variables.

[0009] However, implementing a risk assessment model update can be an arduous task because when any model update is implemented, a corresponding impact analysis of that update must also be performed. An impact analysis determines whether or not the updated logic rules will adversely impact any existing customer data. As an example, the updated risk assessment model should not incorrectly classify a low-financial-risk customer as being high risk. This entire process, including the update and the corresponding impact analysis can take many weeks to complete.

[0010] And even worse, if the impact analysis reveals an adverse impact, the entire update is discarded. The process is then restarted and repeated with the appropriate logic changes which then takes much longer. Furthermore, this process can take additional time if the impact analysis is for a large data set such as that for a large financial institution that has millions of clients. Oftentimes, in such cases, the impact analysis is conducted on a small sample of existing customers to save time.

[0011] Accordingly, examples of the present disclosure address the foregoing by providing a system and method for assessing data records to generate a risk assessment score. For some examples, the method begins by mapping multiple keys to respective pools of records, each pool of records having corresponding values. The pools of records may be obtained by restructuring customer records into a combined data pool of records. The mapping operation may include mapping a first key to a first pool of records of a first array and mapping a second key to a second pool of records of a second array. The method then applies logic rules to values of the pools of records that are in the same index or position of the arrays to generate a risk assessment score.

[0012] In this manner, by restructuring the data structure of customer records into a combined pool of records, the present disclosure achieves aggressive data compression resulting in a 100× (one hundred-fold) magnitude increase in data compression. The result is a fast, efficient and less time consuming risk assessment model update process. Both the risk model updates and the impact analyses can be performed quickly in a matter of minutes instead of many weeks to complete. And, generation of the actual risk assessment score is much faster with an execution time of 800 ms instead of many days.

[0013] If the impact analysis reveals an adverse impact, restarting and repeating the process with the appropriate logic changes is seamless and effortless. And the impact analysis is not limited to data set samples but can be applied to large datasets as with large financial institutions that have upwards of a hundred million clients.

[0014] FIG. 1 illustrates a system 100 for assessing data records to determine customer financial risks according to an example of the present disclosure. In FIG. 1, the system 100 includes an application server 102 and a database server 104.

[0015] As implied by its name, database server 104 is a computing server that uses a database application, e.g., SQL (Structured Query Language), to manage data on one or more databases 106. The data management (by database server 104) may include storing, retrieving and authenticating end-user access to all of the data stored on database 106. Database 106 may also store customer records (of a financial entity, for example).

[0016] Application server 102 may include computing software or code to execute web or desktop applications for use by system 100. Application server 102 may also include runtime libraries and connectors to database 106. As shown, application server 102 may be behind a web server 108 (including a processor 109).

[0017] Web server 108 may be a combination of software and/or hardware that accepts HTTP requests initiated via a webpage 112. Any one of end user 120 and end user 128 may initiate communication via webpage 112 by making a request for a specific resource using HTTP. Then the web server 108 can respond with either the content of that resource or with an error message.

[0018] In one implementation, end user 128 may request via webpage 112 to add, edit or delete customer records; responsively, web server 108, in conjunction with application server 102 and database server 104, may fulfill the user request. Similarly, an administrator 124 may be tasked to implement risk model changes (via webpage 112 or other internal user interfaces within the enterprise data network).

[0019] As used in the present disclosure, a risk model is a list of risk rules that can be applied to a pool of customers to generate risk assessment scores. An example of such a risk rule is “V:politically-exposed=“Yes” OR V:client-country-codes in C:high-risk-countries.”

[0020] In FIG. 1, system 100 further includes an API (Application Programming Interface) 110 and a logic engine 114 that are used to apply logic rules to data such as the customer records of an entity including financial institutions or other entity types. Logic engine 114 may be a module, software, or program (usually self-contained) that takes in a set of variables and corresponding values, evaluates a set of predefined conditions, and builds a result set based on true condition.

[0021] API 110 may be a set of communication protocols to receive user requests to analyze the impact of risk model changes on customers as will be further described below. Such requests may then be delivered to logic engine 114 for execution. Similarly, for some examples, API 110 may receive customer scoring requests from other applications and then deliver the customer scoring requests to logic engine 114 for execution.

[0022] As shown in FIG. 1, the logic engine 114 may be communicably coupled to a cloud storage 107 and database 106. As implied by its name, cloud storage 107 may be a remotely stored cloud such as S3™ to store available risk models. In contrast, because database 106 is local and within a secure enterprise data network (not shown), database 106 may store customer records and other highly sensitive data.

[0023] Specifically, for some examples, the present disclosure combines customer records into a customer data pool to achieve compression of large amounts of data and to facilitate the generation of risk assessment scores and the corresponding impact analysis. Here, a customer data pool, as used herein, is composed of values from across a plurality of customer records (e.g., R.sub.1, R.sub.2 . . . N.sup.th of FIG. 3B).

[0024] For example, a first customer record may have the following values or datapoints: name=John Doe; doing-business-in-country=ZW, CA; politically-exposed-person=No; naic-code=115112. A second customer record R.sub.2 may have: name=Jane Doe; doing-business-in-country=ZW, US; politically-exposed-person=Yes; naic-code=441221. An N.sup.th customer record R.sub.N may include: name=Peter Doe; doing-business-in-country=CA; politically-exposed-person=No; industry-code=441221.

[0025] Based on the above, a first customer data pool for above records may include the names: John Doe, Jane Doe, and Peter Doe. In other words, a customer data pool includes values from a row of a plurality of customer records. Another example of a customer data pool based on the above records may include the datapoints: doing-business-in-country=NZ; doing-business-in-country=CA; naic-code=441221; and doing-business-in-country=US. Further yet, another example of a customer data pool includes the values: naic-code=115112, naic-code=441221.

[0026] As further described below with reference to FIG. 3B, the customer data pools may be stored as a plurality of arrays where the same position of the plurality of arrays is associated with each individual record and a plurality of keys may be mapped to the data pool of each array.

[0027] In one implementation, the present disclosure achieves aggressive data compression resulting in a 100× (one hundred-fold) magnitude increase in data compression by restructuring customer records from a data structure where each customer record has its own individual dataset to a data structure where customer records are combined into a customer data pool.

[0028] Briefly, in operation, end user 128 may be an internal end user from a line of business (LOB) of a financial entity. End user 128 may desire a financial risk assessment score for a new customer. End user 128 begins by using webpage 112 to send a financial risk assessment score request to API 110 and web server 108.

[0029] In turn web server 108 and/or application server 102 may include one or more processors to cause the logic engine 114 to apply logic rules to the customer data pool (having restructured and compressed customer data) to generate a risk assessment score. Specifically, logic engine 114 may request the latest risk model from cloud storage 107. Logic engine 114 then uses the risk model to score the customer or collection of customers identified in the request.

[0030] End user 120 may also employ system 100 to view the impact of changes to risk models. End user 120 may send a request to view the impact of changes that have been made to a particular risk model by end user 120. System 100 receives the request and causes logic engine 114 to request the target customer pool from database 106. Logic engine 114 then applies logic rules based on the modified risk model to the customer data pool (having restructured compressed customer data) and then displays the impact change results to end user 120.

[0031] The impact change results might include the level of risk (high, medium or low) or a risk assessment score. Such a level of risk or risk assessment score may reveal that the change to the modified risk model has inadvertently misclassified a low-risk customer into a higher risk category (for example). In such cases, end user 120 may discard the modified risk model and restart the risk model revision process. The impact change results may also include evaluations of the risk assessment rules used to score the customer records that may indicate the relative importance of each rule. Additionally, impact change results may be further summarized by their associated risk category.

[0032] FIG. 2 illustrates an example of a risk model 200 and a customer pool 202 syntax for logic engine 114 of FIG. 1. In one example, logic engine 114 may be caused by a processor (e.g., 109 of FIG. 1) to apply logic rules to BitSet values of customer pool 202.

[0033] In FIG. 2, customer pool 202 may include a map 204 object that maps a string (key) to a BitSet of 1s and 0s: map<string, bitset>features. As an example, at 208, the key “domicile-country-code=US” is mapped to the BitSet [1, 0, 0, 1, 0, 1, 1, 0,].

[0034] The risk model 200 may include a list 210 interface that implements multiple rules such as rule 212. The rule 212 may itself be based on a logical combination of expressions 214 such as “domicile-country-code in [US, CA] AND (industry=[ ] OR money-service-business=Y) as in FIG. 2.

[0035] FIG. 3A is an object-oriented syntax 300 to add an amount of points to the total of a risk assessment score of a customer 308. Specifically, in FIG. 3A, line of code 318 illustrates that if customer 308 is doing business in the US, CA, or NZ as shown at 320, a 50-point score (shown at 322) is added to the customer's risk assessment score. In this case, the key (question or datapoint) doing-business-in-country 304 has a country code value ZW for Zimbabwe, and US for United States, as depicted as 302. Because customer 308 is doing business in the US, the 50-point score is assigned to customer 308. As such, the risk assessment score of customer 308 is higher indicating that customer 308 may be a higher-risk customer.

[0036] Two additional keys, namely politically-exposed-person 310 and naic-code 314, also facilitate risk assessment of a customer. Here, politically-exposed-person 310 has a value N for “no” as shown at 312 and naic-code 314 has a value of 115112 as shown at 316. Note also that if customer 308 were operating in the motorcycle dealership industry (North American Industry Code (NAIC) 441221), object-oriented syntax 300 would include the following key (or datapoints or questions):

[0037] class DataPoint {(“naic-code”, “441221”).

[0038] To successfully execute the above lines of code, each and every customer record has its own customer 308 object, and its own data set. In other words, for each customer, all of the data including responses to the above questions are stored in a customer 308 object for the customer. As such, if a financial institution has 100 million customers, then 100 million customer objects are stored in memory so that memory consumption by the data structure is a substantial and sizeable 4 TB of memory. The data structure for such a syntax can be very unwieldy and inefficient.

[0039] Moreover, scoring 100 million customer objects in this manner takes about 21 days even though memory consumption is low because customers are scored one by one. This object-oriented syntax 300 can also be very inefficient, analyzing risk model impacts by scoring customers one by one and then aggregating the data.

[0040] Unlike the system of FIG. 3A, the present disclosure addresses the foregoing by providing an efficient and fast system that enables utilization and compression of a large amount of data. Accordingly, FIG. 3B illustrates a customer-pool syntax 350 in accordance with examples of the present disclosure. Here, as in FIG. 3A, customer-pool syntax 350 also assigns an amount of points to a total risk assessment score.

[0041] However, in FIG. 3B, all customers are pooled into a CustomerPool 358. If the pooled customers are doing business in the US, CA, or NZ, a 50 point score is assigned to the customers. Here, unlike the object-oriented syntax 300 of FIG. 3A where each customer has its own data set, the customer-pool syntax 350 of the present disclosure combines and compresses all customer data into a customer data pool.

[0042] Specifically, in FIG. 3B, a plurality of customer records R.sub.1, R.sub.2 . . . R.sub.N are shown. Here, each one of the values 356 is from a different customer record R.sub.1, R.sub.2 . . . R.sub.N combined into a customer data pool 358 or array A.sub.1. For example, the first value 356 is a 1 from customer record R.sub.1. The second value 356 is a 1 from customer record R.sub.2. Thus, the values 356 (1, 1, 0, 1, 0, 0 . . . ) form an array A.sub.1 as previously noted. Note also that the values 356 for the customer data pool 358 are Boolean as will be further described below.

[0043] As noted above, in FIG. 3B, each customer record R.sub.1, R.sub.2 . . . R.sub.N does not have its own dataset but rather has values 354 that are spread out across a plurality of data pools or arrays A.sub.1, A.sub.2, . . . A.sub.N. That is, each individual customer record R.sub.1, R.sub.2 . . . R.sub.N is itself composed of values from across the plurality of arrays A.sub.1, A.sub.2 . . . A.sub.N. As an example, customer record R.sub.1 has values 1, 0, 1, 0. As another example, customer record R.sub.2 has value 1, 1, 0, 1. Although referred to as records, each customer record R.sub.1, R.sub.2 . . . R.sub.N is merely a collection of values in the same position or index of the plurality of arrays A.sub.1, A.sub.2 . . . A.sub.N.

[0044] The arrays A.sub.1, A.sub.2 . . . A.sub.N are all in the same order and also have the same length. Thus, it can be assumed that the first index of each of the arrays A.sub.1, A.sub.2 . . . A.sub.N is all the same customer. The second index is all the same customer, and so forth. As noted, the arrays are the same length. If there are 100 million customers in the first array A.sub.1, the next array A.sub.2 also has 100 million customers, and the A.sub.N.sup.th array has 100 million customers.

[0045] An aspect of the present disclosure is that each key (or question) K.sub.1, K.sub.2 . . . K.sub.N is respectively mapped to the data pool of each array A.sub.1, A.sub.2 . . . A.sub.N (as will be further discussed with reference to FIG. 3). The keys K.sub.1, K.sub.2 . . . K.sub.N are themselves restructured to facilitate data compression. Specifically, a key or question that typically has a character sequence for an answer is restructured to incorporate the character sequence into the question. As a result, answers to key questions can be either True or False (Yes or No), which can be represented as a BitSet of 1s and 0s.

[0046] For example, a typical question may be: which country are you doing business in? The corresponding answer may be a two-letter country code such as US, CA, NZ, etc. This format requires data storage of questions/responses for each customer. Data compression is facilitated by restructuring such a question to include the country code as follows: “doing-business-in-countries=US.” The answer can then be a 1 if a customer is doing business in the US or a 0 if they are not. Thus, the response for each one of 100 million customers (for example) can be represented by either a 1 or a 0. The result is an array of integers of 1s and 0s as shown in FIG. 3B.

[0047] Referring now to FIG. 3B, the arrays A.sub.1, A.sub.2 . . . A.sub.N can respectively, form a matrix defined by: [0048] K.sub.1[R.sub.11, R.sub.12 . . . R.sub.1N], K.sub.2[R.sub.21, R.sub.22 . . . R.sub.2N], K.sub.N[R.sub.N1, R.sub.N2 . . . R.sub.NN], where [0049] K.sub.1=“doing-business-in-countries=ZW,” R.sub.11=1, R.sub.12=1 and R.sub.1N=0; [0050] K.sub.2=“politically-exposed-person=Y, R.sub.21=0, R.sub.22=1 and R.sub.2N=0; [0051] K.sub.3=“naic-code=115112”, R.sub.31=1, R.sub.32=0 and R.sub.3N=1 and [0052] K.sub.N=“doing-business-in-country=US, R.sub.N1=0, R.sub.N2=1 and R.sub.NN=1.

[0053] As can be seen, the plurality of keys K.sub.1, K.sub.2, K.sub.3 . . . K.sub.N are questions, and the data pool values are corresponding Boolean responses to the questions. Thus, for key (question) K.sub.1 “doing-business-in-countries=ZW,” the response “1” indicates that the customer does business in ZW while a “0” indicates that the customer does not do business in ZW. As another example, for key (question) K.sub.3 “naic-code=115112,” a “1” indicates that customer operates in the agriculture industry, and a “0” indicates that customer does not operate in that industry. In this manner, responses are compressed into BitSet of 1s and 0s such that for 100 million customers for example, a data compression goes from 4 TB for the syntax of FIG. 3A to only 40 GB for examples according to the present disclosure.

[0054] Moreover, the restructured data format also plays a role in latency. Because the present data has been compressed into an array of 1s and 0s, questions can be answered quickly sometimes in as little as 5 milliseconds by applying a logical OR to each of the questions. For example, if the question that is answered is “Is the customer doing business in the US or CA or CN or NZ?” that answer can be recorded efficiently by taking doing a logical OR of the compressed array of 1's and 0's so that the result is either a 0 or a 1. The result is a fast, efficient risk assessment scoring and updating particularly for big data.

[0055] FIG. 4 is a data assessment method 400 for according to examples of the present disclosure. At block 402, in one example, the data assessment method 400 begins by using a map object to map a plurality of keys K.sub.1, K.sub.2, K.sub.3 . . . K.sub.N to a respective plurality of the pools of records [R.sub.11, R.sub.12 . . . R.sub.1N], [R.sub.21, R.sub.22 . . . R.sub.2N] [R.sub.N1, R.sub.N2 . . . R.sub.NN]. As used herein, a key is a question for which a Boolean value is stored.

[0056] The operation of mapping a plurality of keys K.sub.1, K.sub.2, K.sub.3 . . . K.sub.N to a respective plurality of the pools of records [R.sub.11, R.sub.12 . . . R.sub.1N], [R.sub.21, R.sub.22 . . . R.sub.2N], [R.sub.N1, R.sub.N2 R.sub.NN] may include mapping a first key K.sub.1 to a first pool of records [R.sub.11, R.sub.12 . . . R.sub.1N] of a first array A.sub.1 and mapping a second key K.sub.1 to a second pool of records [R.sub.21, R.sub.22 . . . R.sub.2N] of a second array A.sub.2.

[0057] At block 404, the data assessment method 400 applies logic rules to values of the pools of records that are in the same index or position of the first and the second array to generate a risk assessment score for a record corresponding to that index or position.

[0058] The present disclosure may employ a software stack to enlist the underlying tools, frameworks, and libraries used to build and run example applications of the present disclosure. Such a software stack may include PHP, React, Cassandra, Hadoop, Swift, etc. The software stack may include both frontend and backend technologies including programming languages, web frameworks servers, and operating systems. The frontend may include JavaScript, HTML, CSS, and UI frameworks and libraries. In one example, a MEAN (MongoDB, Express.js, AngularJS, and Node.js) stack may be employed. In another example, a LAMP (Linux, Apache, MySQL, and PHP) stack may be utilized.

[0059] Any suitable programming language can be used to implement the routines of particular examples including Java, Python, JavaScript, C, C++, assembly language, etc. Different programming techniques can be employed such as procedural or object oriented. The routines may execute on specialized processors.

[0060] The specialized processor may include memory to store a set of instructions. The instructions may be either permanently or temporarily stored in the memory or memories of the processing machine. The processor executes the instructions that are stored in the memory or memories in order to process data. The set of instructions may include various instructions that perform a particular task or tasks, such as those tasks described above. Such a set of instructions for performing a particular task may be characterized as a software program.

[0061] As used in the description herein and throughout the claims that follow, “a”, “an”, and “the” include plural references unless the context clearly dictates otherwise. Also, as used in the description herein and throughout the claims that follow, the meaning of “in” includes “in” and “on” unless the context clearly dictates otherwise.

[0062] While the above is a complete description of specific examples of the disclosure, additional examples are also possible. Thus, the above description should not be taken as limiting the scope of the disclosure which is defined by the appended claims along with their full scope of equivalents.