A user credit scoring method and system based on multi-source behavior data

Abstract

The present application provides a user credit scoring method and system based on multi-source behavior data, the method comprising: obtaining user behavior data to construct standardized multi-module behavior event records; using behavior event records as nodes to construct a behavior graph in units of users, and constructing directed edges according to the time stamps of event occurrence; based on the behavior graph, using a constrained maximum edge weight path search algorithm to construct a user behavior path; structurally matching the high-credit user behavior path template set with each user behavior path, calculating the path deviation degree of each user behavior path, and obtaining the minimum deviation score; combining the minimum deviation score and the matched optimal matching path, predicting the risk label of the user through a credit scoring model based on binary classification learning, and outputting the customer credit score.

Description

Technical Field

[0001] This invention belongs to the field of user credit scoring, and in particular relates to a user credit scoring method and system based on multi-source behavioral data. Background Technology

[0002] With the ongoing digital transformation of the financial industry, user interaction patterns within the banking system have undergone fundamental changes. Traditional offline, static credit models are gradually giving way to risk assessment mechanisms based on online operational behavior. Under this trend, a user's credit performance is no longer solely determined by repayment records or asset information, but increasingly reflects their operational behavior across various banking business modules, such as electronic KYC (eKYC), document upload and recognition (OCR), electronic lending applications (eLending), and transaction review and anti-money laundering (AML). Each type of operation generates behavioral data with different structures, granularities, and semantics, distributed across multiple systems. While this multi-source, heterogeneous behavioral data reflects the user's actual interaction process, the lack of unified modeling standards and behavioral perspectives makes it difficult for current credit scoring systems to fully utilize this data.

[0003] Current mainstream credit scoring methods rely on structured feature modeling, typically by compiling basic user information and credit history to construct input vectors for classification, supplemented by machine learning models for scoring. While these methods perform reasonably well in traditional lending scenarios, they are almost ineffective when dealing with "cold start users" who are opening accounts for the first time and have no credit history. In recent years, although deep learning models have attempted to directly model using raw data in some scenarios, they still face problems in the financial sector, such as poor interpretability, difficulty in regulatory auditing, and large training data requirements. Furthermore, they generally lack the ability to handle complex interaction patterns such as behavioral chains, causal sequences, and cross-module paths. More importantly, with the increasing modular deployment and cloud-native architecture of current financial IT systems, scoring systems also face the challenge of flexibly deploying across different platforms and supporting real-time computing and service integration. All these factors contribute to the poor performance of existing credit scoring systems in behavior-driven scenarios, their inability to effectively identify risk factors in complex behavioral chains, and their limitation of the accuracy and efficiency of financial institutions in new customer acquisition, risk warning, and intelligent review processes. Summary of the Invention

[0004] The purpose of this invention is to design a user credit scoring method and system based on multi-source behavioral data, which solves the technical shortcomings in terms of multi-source behavioral data, behavioral chain modeling, user cold start processing, and system deployment flexibility.

[0005] To achieve the above objectives, a user credit scoring method based on multi-source behavioral data is provided in a first aspect of the present invention, the method comprising:

[0006] Step 1: Obtain user behavior data to construct a standardized multi-module behavior event record. The constructed standardized multi-module behavior event record is a five-tuple, including user ID, standardized behavior event type, timestamp of event occurrence, optional behavior description text, and event source module.

[0007] Step 2: Construct a behavior graph using behavior event types as nodes, with each user as the unit, and build directed edges according to the timestamps of the events; retain the previous behavior events based on the behavior graph. A set of high-scoring paths to form a template for high-credit user behavior paths;

[0008] Step 3: Based on the behavior graph, construct user behavior paths using the constrained maximum edge weight path search algorithm; perform structural matching between the high-credit user behavior path template set and each user behavior path, calculate the path deviation of each user behavior path, and obtain the minimum deviation score; wherein the user behavior path corresponding to the minimum deviation score is the optimal matching path;

[0009] Step 4: Combining the minimum deviation score and the optimal matching path, predict the user's risk label using a credit scoring model based on binary classification learning, and output the customer's credit score; wherein the training samples of the credit scoring model come from historical user data, and are generated by posterior credit default results or business score labeling.

[0010] Furthermore, the method also includes:

[0011] Step 5: Package the trained credit scoring model into a microservice component, deploy it using Docker, Kubernetes and FastAPI frameworks, provide a standardized HTTP interface, and integrate scoring caching, call auditing and dynamic hot update mechanisms.

[0012] Furthermore, the step of constructing a behavior graph using behavior event types as nodes, with users as the unit, and constructing directed edges according to the timestamps of the occurrence of behavior event types, specifically includes:

[0013] Obtain the behavioral event type for each user; sort the behavioral event types for each user in chronological order to form a behavioral sequence;

[0014] Based on each user's behavior sequence, a behavior graph is constructed, where each behavior event record is recorded as a node. If the timestamp of the event occurring in the second node is greater than the timestamp of the event occurring in the first node, a directed edge is connected, indicating a point from the first node to the second node.

[0015] Design the edge weights of the behavior graph. , represented as:

[0016] ;

[0017] in, Indicates the first node The timestamp of the event and the second node The time interval between timestamps of the events; This indicates whether the path module has been switched; if the path module is different, it is 1. This indicates whether the redirection was illegal; 1 indicates illegal and 0 indicates legal. This represents the weight coefficients corresponding to the three structural factors, which are tuned using the validation set.

[0018] in, It is a logical function generated by a pre-defined table of legal event jump relationships in the business, which severely punishes illegal jump paths in terms of structure and prevents the formation of misleading high-scoring paths.

[0019] Furthermore, the step of retaining the previous behavior graph These high-scoring paths form a behavioral template set, which serves as a template set for the behavioral paths of high-credit users. Specifically, they include:

[0020] Path selection is performed based on the edge weights of the behavioral graph, a path score is generated, and the path is retained. A set of high-scoring paths constitutes a set of behavior templates; wherein each template path in the set contains a standard behavior type, a corresponding path module sequence, and a path score.

[0021] Furthermore, the path generation objective for constructing user behavior paths using the constrained maximum edge weight path search algorithm based on the behavior graph is:

[0022] ;

[0023] in, For the target path, For behavioral graphs, This is the global path. For the current path; coefficient and Control the suppression weights; , For nodes and nodes ; This is the current path module sequence. This is the sequence of modules for the next path;

[0024] in, The sum of the edge weights of the paths indicates the priority of paths that are close in time, have reasonable module flow, and have legal jumps; Repeated punishment behavior; The penalty path only stays at a single path module or a single process, lacking the span of real financial processes.

[0025] Further, the step of performing structural matching between the high-credit user behavior path template set and each user behavior path, calculating the path deviation degree of each user behavior path, and obtaining the minimum deviation score specifically includes:

[0026] Detect whether the behavior event type in the current user behavior path is not in the set of high-credit user behavior path templates. If there is a mismatch, it is counted as 1, and a deviation result is generated to measure the legality deviation at the attribute level.

[0027] Detect whether the current path module sequence does not conform to the corresponding path template of the high-credit user behavior path template set, indicating that the action of the path template is misaligned or skipped;

[0028] Mark whether the event node is a node on an illegal structure jump path;

[0029] By combining the deviation results, the path template corresponding results, and the illegal structure jump results, a matching is performed to generate the path deviation degree for each user behavior path;

[0030] Match all user behavior paths to obtain the minimum deviation score and the corresponding optimal matching path.

[0031] Furthermore, the process of combining the minimum deviation score and the optimal matching path to predict the user's risk label using a credit scoring model based on binary classification learning, and outputting a customer credit score, specifically includes:

[0032] The minimum deviation score, each behavioral event type in the optimal matching path, and the risk weight of each behavioral event type are input into a deployable credit scoring model to output a customer credit score; wherein the credit scoring model is a shallow neural network structure.

[0033] Furthermore, the training process of the credit scoring model is as follows:

[0034] Obtain the minimum deviation score and the optimal matching path;

[0035] Construct a training set based on the types of real-world risky behavior events;

[0036] The model is trained using a least squares loss function with L2 regularization based on the training set, and the model parameters and risk weights for each behavioral event type are optimized.

[0037] The training process is completed using a standard machine learning framework. Once the credit scoring model is trained, the structured credit scoring model is saved.

[0038] A second aspect of the present invention provides a user credit scoring system based on multi-source behavioral data, the system comprising:

[0039] The task initialization module is used to acquire user behavior data to construct a standardized multi-module behavior event record. The constructed standardized multi-module behavior event record is a five-tuple, including user ID, standardized behavior event type, timestamp of event occurrence, optional behavior description text, and event source module.

[0040] The rating graph module is used to construct a behavior graph for each user, using behavior event types as nodes, and to build directed edges according to the timestamps of the events; based on the behavior graph, previous... A set of high-scoring paths to form a template for high-credit user behavior paths;

[0041] The risk path construction module is used to construct user behavior paths based on the behavior graph using a constrained maximum edge weight path search algorithm; perform structural matching between the high-credit user behavior path template set and each user behavior path, calculate the path deviation of each user behavior path, and obtain the minimum deviation score; wherein the user behavior path corresponding to the minimum deviation score is the optimal matching path;

[0042] The credit scoring module is used to combine the minimum deviation score and the optimal matching path to predict the user's risk label through a credit scoring model based on binary classification learning, and output the customer's credit score; wherein the training samples of the credit scoring model come from historical user data, and are generated by posterior credit default results or business scoring labels.

[0043] Furthermore, the system also includes:

[0044] The model encapsulation module is used to encapsulate the trained credit scoring model into a microservice component, which is deployed using Docker, Kubernetes and FastAPI frameworks, and provides a standardized HTTP interface. It also integrates scoring caching, call auditing and dynamic hot update mechanisms.

[0045] The beneficial technical effects of the present invention are at least as follows:

[0046] This invention addresses the technical shortcomings of existing credit scoring systems in handling multi-source behavioral data, behavioral chain modeling, user cold start processing, and system deployment flexibility. It proposes a novel credit scoring method and system that integrates modeling and deployment. First, the method introduces a unified behavioral data representation mechanism to normalize user operation records across different business modules, ensuring comparability and integrability of various behaviors. Second, it constructs a behavioral chain model with cross-module, cross-time, and semantic structure to characterize user interaction paths in multiple business processes, thereby uncovering potential behavioral deviation patterns and operational anomalies to support more discriminative and predictive credit scoring. Furthermore, this invention proposes a scoring capability encapsulation scheme for system integration scenarios, supporting the deployment of scoring capabilities as service-oriented components in core bank systems or digital platforms, enabling rapid access and invocation of the scoring model by multiple business systems. This system is particularly well-suited to the data isolation, module decoupling, and microservice operation requirements of fintech architectures, possessing excellent scalability and engineering implementation capabilities. Attached Figure Description

[0047] The present invention will be further described with reference to the accompanying drawings, but the embodiments in the drawings do not constitute any limitation on the present invention. For those skilled in the art, other drawings can be obtained based on the following drawings without creative effort.

[0048] Figure 1 This is a flowchart of a user credit scoring method based on multi-source behavioral data according to the present invention. Detailed Implementation

[0049] Embodiments of the present invention are described in detail below. Examples of these embodiments are shown in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and are only used to explain the present invention, and should not be construed as limiting the present invention.

[0050] In one or more embodiments, such as Figure 1 As shown, a user credit scoring method based on multi-source behavioral data is disclosed, the method comprising the following S1~S5:

[0051] S1. Obtain user behavior data to construct a standardized multi-module behavior event record. The constructed standardized multi-module behavior event record is a five-tuple, including user ID, standardized behavior event type, timestamp of event occurrence, optional behavior description text, and event source module.

[0052] Specifically, during the standardization process, text-based results from the electronic identity authentication module, such as "authentication passed" and "face verification failed," are transformed into standard labels such as "KYC_PASS" and "KYC_FAIL" through rule dictionaries and keyword matching. Numerical data from the AML module, such as transaction amounts, are normalized using standardization functions to ensure that each event is comparable in numerical dimensions.

[0053] Furthermore, the following formula is used for processing standardized numerical features:

[0054] ;

[0055] in, Represents raw numerical data (such as transaction amount); This indicates the mean of the field in the training data; This indicates the standard deviation of the field in the training data; This represents the standardized result, used to eliminate the impact of differences in numerical scales between different modules.

[0056] The system ultimately represents each processed event record as a 5-tuple. ,in:

[0057] The user ID is provided by the system log or module interface; Indicates the standardized behavior event type (such as "KYC_FAIL" or "UPLOAD_SUCCESS"). The timestamp representing the occurrence of the event is uniformly converted to a Unix timestamp; Optional behavioral description text, used only for log readability; Indicates the module from which the event originates (such as "OCR module", "AML module", etc.).

[0058] All standardized event records will be stored in a unified behavior event set, with each record having a unified structure, which will facilitate quick conversion into node form during subsequent graph structure construction.

[0059] For example, the original three records are: OCR upload successful; eKYC authentication failed; AML rule 5 triggered.

[0060] After standardization, it will be uniformly converted into:

[0061] User ID: user123, Behavior Type: UPLOAD_SUCCESS, Time: 2025-05-12 10:05:01, Source Module: OCR;

[0062] User ID: user123, Behavior Type: KYC_FAIL, Time: 2025-05-12 10:07:43, Source Module: eKYC;

[0063] User ID: user123, Behavior type: AML_TRIGGERED_RULE_5, Time: 2025-05-12 10:15:22, Source module: AML.

[0064] S2. Construct a behavior graph using behavior event records as nodes, with each user as the unit, and build directed edges according to the timestamps of the events; retain the previous behavior events based on the behavior graph. A set of high-scoring paths are used to form a template set of behavior paths for high-credit users.

[0065] Specifically, this step aims to standardize the multi-module behavioral event records output from step one. A structured behavioral graph is constructed to capture the user's operational chain, behavioral logic, and module transitions in multi-module financial processes. This graph not only preserves the temporal order of behaviors but also incorporates business-specific constraints such as module switching, abnormal jumps, and repetitive behaviors. It is also used to extract well-structured behavioral path templates from high-credit users for reference in subsequent path generation and deviation modeling steps.

[0066] The system uses each user The behavioral event records are sorted chronologically, forming a behavioral sequence. Subsequently, a behavioral graph is constructed. Each of them It is a node, if Then connect the directed edges. .

[0067] To enhance the graph structure's ability to accurately represent business processes, the system defines the following innovative edge weight function to quantify the continuity and rationality of behaviors between events:

[0068] ;

[0069] in, Represents behavioral events and The time interval; This indicates whether the module has been switched; if the modules are different, it is 1. Indicates whether the redirection was illegal (1 for illegal, 0 for legal); This represents the weight coefficients corresponding to the three structural factors, which are tuned by the validation set (e.g., , , );

[0070] in It is a logical function generated by a pre-defined legal event jump relationship table. Its design ensures that illegal jump paths (such as skipping KYC for direct loans) are severely punished structurally to prevent the formation of misleading high-scoring paths.

[0071] After the graph is constructed, from the high-credit user group Frequent, stable, and cross-module complete behavioral paths are extracted from the graph set and used as a reference template set. The path filtering uses the following scoring function:

[0072] ;

[0073] in, The edge weights defined above are used to measure the smoothness of behavior; This indicates the number of unique modules appearing in the path, representing the process coverage. Represents the logarithm of illegal redirect events (from) (number of sides); Indicates the module coverage reward coefficient (e.g.) ), For jump penalty coefficient (e.g.) A higher path score indicates more continuous behavior, richer modules, and a more rational structure. (The system retains the previous version.) High-scoring paths constitute a set of behavioral templates. .

[0074] For example, the path examples are: "UPLOAD_IMAGE" → "KYC_PASS" → "LOAN_APPLY" → "AML_PASS"; "OCR_FAIL" → "REUPLOAD" → "KYC_PASS" → "LOAN_APPLY".

[0075] Each template path contains a standard behavior type. Sequence, corresponding module sequence This is for use in subsequent model comparisons.

[0076] Further output: Behavioral graph of each user High-credit user behavior path template collection It includes ratings, module sequences, and behavioral tags.

[0077] S3. Based on the behavior graph, construct user behavior paths using the constrained maximum edge weight path search algorithm; perform structural matching between the high-credit user behavior path template set and each user behavior path, calculate the path deviation of each user behavior path, and obtain the minimum deviation score; wherein the user behavior path corresponding to the minimum deviation score is the optimal matching path.

[0078] Specifically, this step, based on the preceding behavior graph structure modeling and reference path template extraction, further generates the user's current behavior path and calculates its deviation from the reference path set. The deviation score, as the core risk feature of this patent, is a key indicator for distinguishing between "users within the process" and "users outside the process." Unlike traditional risk scores based on field comparisons or black-box models, this step uses the behavior graph as input, combined with a standard process template structure, and constructs an interpretable, quantifiable, and business-verifiable behavior deviation system through graph path search, structure alignment, and scenario regularization, ultimately forming the ability to identify high-risk behavior chains.

[0079] First, based on the map Construct user behavior paths using the constrained maximum edge weight path search algorithm. The goal is to identify the "complete chain of actions currently being executed". To avoid misidentifying short-jump paths or single-module loop paths as main paths, structural integrity and repetitive behavior penalties are introduced during the search process. The path generation objective is:

[0080] ;

[0081] in:

[0082] The first item is the sum of the edge weights of the paths, which comes from the edge weight definition in step two. It indicates that paths with similar time, reasonable module flow, and legal jumps are given priority.

[0083] The second item: repeated punitive behaviors, such as repeatedly "applying for a loan" or "failing KYC";

[0084] The third point: The penalty path is limited to a single module (such as OCR) or a single process, lacking the scope of real financial processes;

[0085] coefficient and The suppression weights are typically set to 0.7 and 0.9, respectively, and are optimized based on historical training samples.

[0086] Then the system will With each Perform structural matching and calculate path deviation. Due to issues such as non-standard path fluctuations, skipping steps, and reversals in user behavior, traditional edit distance cannot meet the business accuracy requirements of financial processes. Therefore, the following module offset matching function with structured regularization is designed:

[0087] ;

[0088] in, Indicates the current reference path number Bit events in the user path Allowed windows on the screen, such as allowed offsets Individual event locations increase tolerance; Indicates a reference event If it does not appear in the current window, it is marked as an offset. This indicates a mismatch between the corresponding modules, meaning the module behavior is misaligned or skipped. Indicates a flag event Whether a node is on an illegal structure jump path (such as AML before KYC) is determined by a predefined flowchart; The impact strength of the control module jump is generally taken as 1.2; This is a strong penalty for illegal paths, and its value can reach 2.0 or even higher.

[0089] Furthermore, this function integrates path matching location flexibility, module matching rationality, and penalties for illegal paths to realistically simulate whether users are operating within the "standard process" and accurately characterize the degree of deviation. The system performs this on all... Perform the above matching to obtain the final minimum deviation score:

[0090] ;

[0091] The higher the score, the more the user's behavior deviates from the standard process, which manifests as process jumps, structural omissions, and illegal cross-module behaviors. These will be used as core features in the scoring model.

[0092] Output: Minimum deviation score Quantifying the differences between user behavior chains and standard processes; optimal matching path The reference path closest to the current behavior can be used for review, interpretable output, and rating correction.

[0093] S4. Combining the minimum deviation score and the optimal matching path, predict the user's risk label using a credit scoring model based on binary classification learning, and output the customer credit score; wherein the training samples of the credit scoring model come from historical user data, and are generated by posterior credit default results or business score labeling.

[0094] Specifically, the goal of this step is to build a credit scoring model that can learn the patterns of user behavior risk scoring, with the user behavior deviation score output from the previous step as the input. and its matching reference path By introducing a structural attention factor and a process deviation regularization mechanism, a scoring model with structural expressive capabilities is constructed. In this model, These are considered extracted "behavioral risk factors," while The behavioral labels in the model are embedded as structural path labels to assist in the behavioral attention mechanism during the modeling process. The final output is a trained structured scoring model. This will be used in the subsequent deployment of the scoring system.

[0095] The modeling task is a binary classification learning problem, namely, predicting whether a user is a "high-risk user". Training samples are derived from historical user data, and their labels are generated from posterior credit default results or business scoring. This invention uses a deployable shallow neural network structure for modeling, with the input layer consisting of the following:

[0096] First dimension: Minimum deviation score ;

[0097] Second dimension: Reference path Each key behavior tag The occurrence state is used as a vector input. , dimension , For the set of all behavior labels, This indicates that it appeared in the user path. Otherwise, it is 0;

[0098] Third dimension: Risk weight of each label The values ​​are set by the expert system or business knowledge, for example, "KYC_FAIL" is set to 1.5 and "UPLOAD_IMAGE" is set to 0.7.

[0099] Furthermore, the final model output is defined as follows:

[0100] ;

[0101] in: Model parameters representing deviation factors; Indicates the first Risk weights for each reference behavior; Indicates whether the user has performed this action; Indicates the bias term; This represents the activation function (such as Sigmoid or ReLU).

[0102] The innovation of this formula lies in integrating process structure label information into modeling features through "path attention + risk weighting" and combining deviation as a risk regularization, thereby achieving the integration of graph structure path and modeling algorithm.

[0103] The model training process is as follows:

[0104] For each historical user, perform steps one through three to obtain... ;

[0105] Construct a training set based on real risk events (such as whether the payment is overdue);

[0106] Training is performed using a least-squares loss function with L2 regularization, and the parameters are optimized. With risk-weighted parameters (if not fixed);

[0107] The training process is completed using standard machine learning frameworks such as PyTorch and TensorFlow.

[0108] After the model training is complete, save the structured scoring model. It includes modules for parameter weights, structure definition, and risk interpretation.

[0109] Output: Credit Scoring Model It contains the set of parameters after training; the model structure configuration file, which is used for loading and use when the scoring function is called later.

[0110] S5. The trained credit scoring model is encapsulated as a microservice component, deployed using Docker, Kubernetes and FastAPI frameworks, and provides a standardized HTTP interface. It also integrates scoring caching, call auditing and dynamic hot update mechanisms.

[0111] Specifically, the goal of this step is to refine the scoring model trained in the previous step. Service-oriented deployment enables financial business systems to access the system in a stable, callable, and auditable manner in real time. The deployment process follows the core requirements of financial technology systems for high availability, low latency, and compliance tracking. It adopts a microservice container architecture to encapsulate the model's runtime logic, builds a standard scoring interface, and ensures the efficiency and security of system operation through mechanisms such as scoring caching, interface auditing, and dynamic model hot reloading.

[0112] The model deployment uses a Docker+Kubernetes+FastAPI framework to implement the scoring microservice, and the core deployment process is as follows:

[0113] Model loading: Read when the service starts. The system defines the structure and weight parameters, and calls a framework (such as PyTorch or ONNX) to complete the loading. The loading script registers the interface name, version number, and the business tag to which the model belongs (such as "Anti-fraud scoring model v1.0").

[0114] Interface definition: The service exposes a standard HTTP POST interface / score, and the interface request body is:

[0115] {

[0116] "user_id":"u123456",

[0117] "input_features":"encodedstring", / / Compressed or encrypted model input vector

[0118] "request_id":"req20250102001"

[0119] }

[0120] After receiving the data, the service decodes the input_features into a model input tensor and then calls the model. Get the rating results .

[0121] Rating response structure:

[0122] {

[0123] "request_id":"req20250102001",

[0124] "score": 0.837,

[0125] "risk_level":"MEDIUM",

[0126] "model_version":

[0127] "v1.0","timestamp":1700000000

[0128] }

[0129] Rating caching mechanism: To reduce the overhead of duplicate ratings in high-concurrency scenarios, a rating caching module is embedded in the service. The cache key consists of the user ID and the request hash value. Upon cache hit, historical ratings are returned directly. Rating response time is:

[0130] ;

[0131] in: This is to allow for caching retrieval time, typically <1ms; The model inference time (e.g., 5ms~20ms); System target settings for cache hit rate .

[0132] Call auditing mechanism: Every API call is recorded in the "Scoring Audit Log Table". The log content includes:

[0133] Request timestamp;

[0134] User ID (de-identified and encrypted);

[0135] Request ID;

[0136] Response score and risk level;

[0137] Interface latency;

[0138] The model version used. Audit logs are uploaded to the bank's risk control audit platform or ELK log stack on a regular basis, supporting post-event traceability and compliance review.

[0139] Model hot update mechanism: Model microservices support hot reloading of new model versions with zero downtime. The process for deploying the new model is as follows:

[0140] Mount the new model structure and weights in the background;

[0141] First, conduct a self-test of the model to check the scoring range and response time;

[0142] If successful, the request will be routed from Switch to The original model remains in cold standby mode and supports rollback.

[0143] Version switching records are written to the version change log.

[0144] Output: Deployable credit scoring microservice container image and image address (e.g., registry.ai / credit-scorer:v1.0); Credit Scoring Service API documentation (OpenAPI / Swagger format); Model call audit log table design; Service deployment performance evaluation results (e.g., average response time). Cache hit rate (and other indicators).

[0145] In one or more embodiments, a user credit scoring system based on multi-source behavioral data is disclosed, the system comprising:

[0146] The task initialization module is used to acquire user behavior data to construct a standardized multi-module behavior event record. The constructed standardized multi-module behavior event record is a five-tuple, including user ID, standardized behavior event type, timestamp of event occurrence, optional behavior description text, and event source module.

[0147] The rating graph module is used to construct a behavior graph based on users, using behavioral event records as nodes, and to build directed edges according to the timestamps of the events; based on the behavior graph, previous data is retained. A set of high-scoring paths to form a template for high-credit user behavior paths;

[0148] The risk path construction module is used to construct user behavior paths based on the behavior graph using a constrained maximum edge weight path search algorithm; perform structural matching between the high-credit user behavior path template set and each user behavior path, calculate the path deviation of each user behavior path, and obtain the minimum deviation score; wherein the user behavior path corresponding to the minimum deviation score is the optimal matching path;

[0149] The credit scoring module is used to combine the minimum deviation score and the optimal matching path to predict the user's risk label through a credit scoring model based on binary classification learning, and output the customer's credit score; wherein the training samples of the credit scoring model come from historical user data, and are generated by posterior credit default results or business scoring labels.

[0150] Furthermore, the system also includes:

[0151] The model encapsulation module is used to encapsulate the trained credit scoring model into a microservice component, which is deployed using Docker, Kubernetes and FastAPI frameworks, and provides a standardized HTTP interface. It also integrates scoring caching, call auditing and dynamic hot update mechanisms.

[0152] It is worth noting that the specific workflow of the user credit scoring system based on multi-source behavioral data provided in this embodiment of the invention is the same as that of the user credit scoring method based on multi-source behavioral data described in the above embodiment, and will not be repeated here.

[0153] This invention also provides a user credit scoring device based on multi-source behavioral data, including a processor, a memory, and a computer program stored in the memory and configured to be executed by the processor. When the processor executes the computer program, it implements the steps described in the above embodiment of a user credit scoring method based on multi-source behavioral data, for example... Figure 1 The steps S1 to S5 described above; or, when the processor executes the computer program, it implements the functions of each module in the above system embodiments.

[0154] For example, the computer program may be divided into one or more modules, which are stored in the memory and executed by the processor to complete the present invention. The one or more modules may be a series of computer program instruction segments capable of performing specific functions, which describe the execution process of the computer program in the user credit scoring device based on multi-source behavioral data.

[0155] The user credit scoring device based on multi-source behavioral data can be a computing device such as a desktop computer, laptop, handheld computer, or cloud server. This device may include, but is not limited to, a processor and memory. Those skilled in the art will understand that the device may also include input / output devices, network access devices, buses, etc.

[0156] The processor can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. The general-purpose processor can be a microprocessor or any conventional processor. This processor is the control center of the user credit scoring device based on multi-source behavioral data, connecting all parts of the device via various interfaces and lines.

[0157] The memory can be used to store the computer program and / or modules. The processor implements various functions of the user credit scoring device based on multi-source behavioral data by running or executing the computer program and / or modules stored in the memory and calling the data stored in the memory. The memory may mainly include a program storage area and a data storage area. The program storage area may store the operating system, at least one application program required for a function, etc.; the data storage area may store data created based on the operation of the air conditioner controller, etc. In addition, the memory may include high-speed random access memory, and may also include non-volatile memory, such as hard disk, memory, plug-in hard disk, smart memory card (SMC), secure digital card (SD), flash memory card, at least one disk storage device, flash memory device, or other volatile solid-state storage device.

[0158] The module integrated into the user credit scoring device based on multi-source behavioral data, if implemented as a software functional unit and sold or used as an independent product, can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the above embodiments of the present invention can also be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various method embodiments described above. The computer program includes computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms. The computer-readable medium can include: any entity or device capable of carrying the computer program code, a recording medium, a USB flash drive, a portable hard drive, a magnetic disk, an optical disk, a computer memory, a read-only memory (ROM), a random access memory (RAM), an electrical carrier signal, a telecommunication signal, and a software distribution medium, etc.

[0159] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. The storage medium can be a magnetic disk, optical disk, read-only memory (ROM), or random access memory (RAM), etc.

[0160] The above description represents the preferred embodiments of the present invention. It should be noted that those skilled in the art can make various improvements and modifications without departing from the principles of the present invention, and these improvements and modifications are also considered to be within the scope of protection of the present invention.

Claims

1. A user credit scoring method based on multi-source behavioral data, characterized in that, The method includes: Step 1: Obtain user behavior data to construct a standardized multi-module behavior event record. The constructed standardized multi-module behavior event record is a five-tuple, including user ID, standardized behavior event type, timestamp of event occurrence, optional behavior description text, and event source module. Step 2: Construct a behavior graph using behavioral event records as nodes, with each user as the unit, and build directed edges according to the timestamps of the events; retain the previous... A set of high-scoring paths to form a template for high-credit user behavior paths; Step 3: Based on the behavior graph, construct user behavior paths using the constrained maximum edge weight path search algorithm; perform structural matching between the high-credit user behavior path template set and each user behavior path, calculate the path deviation of each user behavior path, and obtain the minimum deviation score; wherein the user behavior path corresponding to the minimum deviation score is the optimal matching path; Step 4: Combining the minimum deviation score and the optimal matching path, predict the user's behavioral event type using a credit scoring model based on binary classification learning, and output the customer credit score; wherein the training samples of the credit scoring model come from historical user data, and the behavioral event type of the training samples is generated by posterior credit default results or business score labeling. The process of constructing a behavior graph using user-based behavior event types as nodes and building directed edges according to the timestamps of event occurrences specifically includes: Obtain the behavioral event type for each user; sort the behavioral event types for each user in chronological order to form a behavioral sequence; Based on each user's behavior sequence, a behavior graph is constructed, where each behavior event record is recorded as a node. If the timestamp of the event occurring in the second node is greater than the timestamp of the event occurring in the first node, a directed edge is connected, indicating a point from the first node to the second node. Design the edge weights of the behavior graph. , represented as: ； in, Indicates the first node The timestamp of the event and the second node The time interval between timestamps of the events; This indicates whether the path module has been switched; if the path module is different, it is 1. This indicates whether the redirection was illegal; 1 indicates illegal and 0 indicates legal. This represents the weight coefficients corresponding to the three structural factors, which are tuned using the validation set; in, It is a logical function generated by the business's pre-defined legal event jump relationship table, which severely punishes illegal jump paths in terms of structure and prevents the formation of misleading high-scoring paths; The retention based on the behavior map These high-scoring paths form a behavioral template set, which serves as a template set for the behavioral paths of high-credit users. Specifically, they include: Path selection is performed based on the edge weights of the behavioral graph, a path score is generated, and the path is retained. A set of high-scoring paths constitutes a set of behavior templates; wherein each template path in the set contains a standard behavior type, a corresponding path module sequence, and a path score.

2. The user credit scoring method based on multi-source behavioral data according to claim 1, characterized in that, The method further includes: Step 5: Package the trained credit scoring model into a microservice component, deploy it using Docker, Kubernetes and FastAPI frameworks, provide a standardized HTTP interface, and integrate scoring caching, call auditing and dynamic hot update mechanisms.

3. The user credit scoring method based on multi-source behavioral data according to claim 1, characterized in that, The path generation objective of constructing user behavior paths using the constrained maximum edge weight path search algorithm based on the behavior graph is: ； in, For the target path, For behavioral graphs, For global paths, The current path; coefficient and Control the suppression weights; , For nodes and nodes ; This is the current path module sequence. This is the sequence of modules for the next path; in, The sum of the edge weights of the paths indicates the priority of paths that are close in time, have reasonable module flow, and have legal jumps; Repeated punishment behavior; The penalty path only stays at a single path module or a single process, lacking the span of real financial processes.

4. The user credit scoring method based on multi-source behavioral data according to claim 3, characterized in that, The step of performing structural matching between the high-credit user behavior path template set and each user behavior path, calculating the path deviation of each user behavior path, and obtaining the minimum deviation score specifically includes: Detect whether the behavior event type in the current user behavior path is not in the set of high-credit user behavior path templates. If there is a mismatch, it is counted as 1, and a deviation result is generated to measure the legality deviation at the attribute level. Detect whether the current path module sequence does not conform to the corresponding path template of the high-credit user behavior path template set, indicating that the action of the path template is misaligned or skipped; Mark whether the event node is a node on an illegal structure jump path; By combining the deviation results, the path template corresponding results, and the illegal structure jump results, a matching is performed to generate the path deviation degree for each user behavior path; Match all user behavior paths to obtain the minimum deviation score and the corresponding optimal matching path.

5. The user credit scoring method based on multi-source behavioral data according to claim 1, characterized in that, The process involves combining the minimum deviation score and the optimal matching path to predict the user's risk label using a credit scoring model based on binary classification learning, and outputting a customer credit score. Specifically, this includes: The minimum deviation score, each behavioral event type in the optimal matching path, and the risk weight of each behavioral event type are input into a deployable credit scoring model to output a customer credit score; wherein the credit scoring model is a shallow neural network structure.

6. The user credit scoring method based on multi-source behavioral data according to claim 5, characterized in that, The training process of the credit scoring model is as follows: Obtain the minimum deviation score and the optimal matching path; Construct a training set based on the types of real-world risky behavior events; The model is trained using a least squares loss function with L2 regularization based on the training set, and the model parameters and risk weights for each behavioral event type are optimized. The training process is completed using a standard machine learning framework. Once the credit scoring model is trained, the structured credit scoring model is saved.

7. A system for implementing a user credit scoring method based on multi-source behavioral data as described in claim 1, characterized in that, The system includes: The task initialization module is used to acquire user behavior data to construct a standardized multi-module behavior event record. The constructed standardized multi-module behavior event record is a five-tuple, including user ID, standardized behavior event type, timestamp of event occurrence, optional behavior description text, and event source module. The rating graph module is used to construct a behavior graph for each user, using behavior event types as nodes, and to build directed edges according to the timestamps of the events. Based on the behavior graph, previous data is retained. A set of high-scoring paths to form a template for high-credit user behavior paths; The risk path construction module is used to construct user behavior paths based on the behavior graph using a constrained maximum edge weight path search algorithm; perform structural matching between the high-credit user behavior path template set and each user behavior path, calculate the path deviation of each user behavior path, and obtain the minimum deviation score; wherein the user behavior path corresponding to the minimum deviation score is the optimal matching path; The credit scoring module is used to combine the minimum deviation score and the optimal matching path to predict the user's risk label through a credit scoring model based on binary classification learning, and output the customer's credit score; wherein the training samples of the credit scoring model come from historical user data, and are generated by posterior credit default results or business scoring labels.

8. A user credit scoring system based on multi-source behavioral data according to claim 7, characterized in that, The system also includes: The model encapsulation module is used to encapsulate the trained credit scoring model into a microservice component, which is deployed using Docker, Kubernetes and FastAPI frameworks, and provides a standardized HTTP interface. It also integrates scoring caching, call auditing and dynamic hot update mechanisms.

Images