Weakly coupled software evaluation method and apparatus

Abstract

The embodiment of the application provides a weak coupling software evaluation method and device, structured evaluation data is constructed through unified data access and cleaning standardization, evaluation scheme configuration is generated by combining visual drag modeling and meta-model consistency checking, and evaluation report is output by layer-by-layer calculation and capability evolution track correlation rendering of an evaluation execution engine, effectively solving the deficiencies of traditional technologies in data collection preprocessing, evaluation model construction configuration and evaluation execution report output, and providing technical support for software capability weak coupling architecture evaluation and full-process intelligent analysis.

Description

Technical Field

[0001] This application relates to the field of data processing, specifically to a loosely coupled software evaluation method and apparatus. Background Technology

[0002] Existing software evaluation methods have significant shortcomings. Traditional systems perform poorly in evaluation data collection and preprocessing. They typically lack unified access to operational result data and model calculation result data, as well as mechanisms for outlier detection and missing value imputation. They also fail to standardize the format according to unified specifications and add data lineage information for structured storage, resulting in insufficient integrity and traceability of the original evaluation data, making it difficult to provide a reliable data foundation for subsequent refined evaluation modeling.

[0003] Furthermore, existing technologies face bottlenecks in evaluation model construction and scheme configuration. Most systems lack the ability to flexibly combine evaluation computation models by dragging and dropping operator primitives in a visual modeling environment. They also fail to perform consistency checks on operator combinations based on meta-model rules, and struggle to associate and bind evaluation computation models with evaluation index systems and allocate weight parameters hierarchically to form a complete evaluation scheme configuration. This results in insufficient flexibility and standardization in the construction of evaluation models, affecting the reusability and accuracy of evaluation schemes.

[0004] The existing system has technical shortcomings in assessment execution and report output. It lacks a complete closed-loop mechanism that uses an assessment execution engine to perform layer-by-layer indicator calculations on structured data, archive and aggregate capability files by user and organizational identifiers, construct capability evolution trajectories by linking past assessments, and render and output assessment reports based on report templates. This hinders the systematic tracking and presentation of the capability development trajectory of the assessed object. Solving these problems is crucial for improving the loosely coupled architecture design and end-to-end intelligent assessment capabilities of software assessment systems. Summary of the Invention

[0005] To address the problems in the existing technology, this application provides a loosely coupled software evaluation method and apparatus, which can effectively solve the shortcomings of traditional technologies in data acquisition and preprocessing, evaluation model construction and configuration, and evaluation execution report output, and provide technical support for the loosely coupled architecture evaluation and full-process intelligent analysis of software capabilities.

[0006] To solve at least one of the above problems, this application provides the following technical solution: Firstly, this application provides a weakly coupled software evaluation method, including: The original evaluation dataset is obtained by accessing the operation result data and model calculation result data through the data acquisition interface. The original evaluation dataset is then subjected to outlier detection and missing value imputation to obtain a cleaned dataset. The cleaned dataset is read by the data conversion module and standardized according to a unified specification to obtain structured evaluation data. The structured evaluation data is then written into the data storage area after adding data lineage information. The structured evaluation data is read from the data storage area and sent to the visualization modeling environment. The evaluation calculation model is obtained by dragging and dropping operator primitives to combine operators. The evaluation calculation model is then verified for consistency by the operator checking module based on the meta-model rules and associated with the evaluation index system to obtain the evaluation scheme configuration. The evaluation scheme configuration is then assigned index weight parameters according to the hierarchy and submitted to the evaluation execution engine. The evaluation execution engine loads the evaluation scheme configuration and performs layer-by-layer indicator calculation on the structured evaluation data to obtain evaluation result data. The evaluation result data is archived and aggregated according to user identifier and organization identifier to obtain capability archive records. The capability archive records are correlated with the time sequence of previous evaluations to obtain capability evolution trajectory data. The capability evolution trajectory data is read by the report generation module and rendered and outputs an evaluation report document according to the report template.

[0007] Furthermore, it also includes: the data acquisition interface reads job result data and model calculation result data from offline data sources and online data sources respectively according to preset acquisition rules to obtain multi-source heterogeneous data streams; performs field parsing and timestamp alignment on the multi-source heterogeneous data streams to obtain the original evaluation dataset; and classifies and stores the original evaluation dataset according to data type identifiers. The original evaluation dataset is read from the classification storage and outlier detection is performed on each item. Data items that exceed the preset threshold are marked as outlier records to obtain an outlier mark set. The outlier mark set and missing fields are interpolated to obtain the cleaned dataset. The cleaned dataset is written to the conversion queue for the data conversion module to read.

[0008] Furthermore, it also includes: the data conversion module reads the cleaned dataset from the queue to be converted, performs field mapping, type conversion and encoding normalization on the cleaned dataset according to the unified data conversion specification to obtain structured evaluation data, and the structured evaluation data is read by the verification module and performs format integrity verification; Data source identifier, collection timestamp, and conversion rule version are extracted from the structured evaluation data that has passed the format integrity check to generate data lineage information. The data lineage information is associated and bound with the structured evaluation data to obtain evaluation data records with lineage tags. The evaluation data records with lineage tags are written into the data storage area.

[0009] Furthermore, it also includes: reading structured evaluation data from the data storage area and parsing the data field structure to obtain field description information, sending the field description information into the visualization modeling environment as a candidate set of operator input parameters, obtaining the evaluation calculation model by dragging and dropping operator primitives in the preset operator library and configuring the input-output connection relationship between operators in the visualization modeling environment, and having the evaluation calculation model read by the operator checking module; The operator checking module performs operator parameter type matching verification and operator link integrity verification on the evaluation calculation model based on meta-model rules to obtain a verification result identifier. When the verification result identifier is passed, the evaluation calculation model and the evaluation index system are associated and bound according to the mapping relationship between index nodes and operator outputs to obtain the evaluation scheme configuration.

[0010] Furthermore, it also includes: extracting the hierarchical structure information of the evaluation indicator system from the evaluation scheme configuration, calculating the weight value of each level indicator node based on the hierarchical structure information according to a preset weight allocation algorithm to obtain the indicator weight parameter set, and writing the indicator weight parameter set back to the corresponding indicator node in the evaluation scheme configuration; An integrity check is performed on the evaluation scheme configuration carrying the set of indicator weight parameters to obtain the scheme check result. When the scheme check result is passed, the evaluation scheme configuration is serialized and submitted to the task queue of the evaluation execution engine.

[0011] Furthermore, it also includes: the evaluation execution engine reads the evaluation scheme configuration from the task queue and parses the evaluation calculation model and the set of indicator weight parameters, performs layer-by-layer indicator calculation on the structured evaluation data according to the operator execution order defined by the evaluation calculation model, and weights and summarizes the indicator calculation results of each level according to the set of indicator weight parameters to obtain the evaluation result data; The user identifier and organization identifier are extracted from the evaluation result data as archive index keys. The evaluation result data is then grouped and aggregated according to the archive index keys to obtain user dimension evaluation records and organization dimension evaluation records. The user dimension evaluation records and organization dimension evaluation records are then merged and written into the capability file storage area to obtain capability file records.

[0012] Furthermore, it also includes: retrieving historical capability archive records from the capability archive storage area according to user identifier and organization identifier to obtain a historical archive sequence, sorting the historical archive sequence according to the evaluation timestamp and performing index difference calculation between adjacent records to obtain capability evolution trajectory data, and writing the capability evolution trajectory data into the trajectory data cache area; The report generation module reads the capability evolution trajectory data from the trajectory data cache and parses the placeholders and data binding rules in the report template. According to the data binding rules, it fills the capability evolution trajectory data into the corresponding placeholder positions to obtain the rendered report content. The rendered report content is then packaged and output as an evaluation report document according to the report template format.

[0013] Secondly, this application provides a loosely coupled software evaluation apparatus, comprising: The data acquisition module is used to obtain the original evaluation dataset by accessing the operation result data and model calculation result data through the data acquisition interface, perform outlier detection and missing value imputation on the original evaluation dataset to obtain the cleaned dataset, the cleaned dataset is read by the data conversion module and standardized according to a unified specification to obtain structured evaluation data, and the structured evaluation data is written into the data storage area after adding data lineage information. The operator acquisition module is used to read the structured evaluation data from the data storage area and send it into the visualization modeling environment. The evaluation calculation model is obtained by dragging and dropping operator primitives to combine operators. The evaluation calculation model is then verified by the operator checking module based on the meta-model rules and associated with the evaluation index system to obtain the evaluation scheme configuration. The evaluation scheme configuration is then assigned index weight parameters according to the hierarchy and submitted to the evaluation execution engine. The software evaluation module is used by the evaluation execution engine to load the evaluation scheme configuration and perform layer-by-layer indicator calculation on the structured evaluation data to obtain evaluation result data. The evaluation result data is archived and aggregated according to user identifier and organization identifier to obtain capability file records. The capability file records are correlated with the time sequence of previous evaluations to obtain capability evolution trajectory data. The capability evolution trajectory data is read by the report generation module and rendered and outputs an evaluation report document according to the report template.

[0014] Thirdly, this application provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the program to implement the steps of the loosely coupled software evaluation method described above.

[0015] Fourthly, this application provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of the loosely coupled software evaluation method described above.

[0016] Fifthly, this application provides a computer program product, including a computer program / instructions that, when executed by a processor, implement the steps of the loosely coupled software evaluation method described above.

[0017] As can be seen from the above technical solution, this application provides a loosely coupled software evaluation method and apparatus. It constructs structured evaluation data through unified data access and standardized cleaning, generates evaluation scheme configuration by combining visual drag-and-drop modeling and meta-model consistency verification, and outputs evaluation report by performing layer-by-layer calculations and rendering associated with capability evolution trajectory through the evaluation execution engine. This effectively solves the shortcomings of traditional technologies in data acquisition and preprocessing, evaluation model construction and configuration, and evaluation execution report output, and provides technical support for the evaluation of loosely coupled architecture of software capabilities and intelligent analysis of the entire process. Attached Figure Description

[0018] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0019] Figure 1 This is a flowchart illustrating the weakly coupled software evaluation method in the embodiments of this application; Figure 2 This is a structural diagram of the weakly coupled software evaluation device in the embodiments of this application. Detailed Implementation

[0020] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0021] The acquisition, storage, use, and processing of data in this application comply with relevant laws and regulations.

[0022] In view of the problems existing in the prior art, this application provides a loosely coupled software evaluation method and apparatus. It constructs structured evaluation data through unified data access and standardized cleaning, generates evaluation scheme configuration by combining visual drag-and-drop modeling and meta-model consistency verification, and outputs evaluation report by performing layer-by-layer calculation and rendering associated with capability evolution trajectory through evaluation execution engine. It effectively solves the shortcomings of traditional technologies in data acquisition and preprocessing, evaluation model construction and configuration, and evaluation execution report output, and provides technical support for the evaluation of loosely coupled architecture of software capabilities and intelligent analysis of the whole process.

[0023] To effectively address the shortcomings of traditional technologies in data acquisition and preprocessing, evaluation model construction and configuration, and evaluation execution report output, and to provide technical support for the evaluation of loosely coupled software capabilities and intelligent analysis throughout the entire process, this application provides an embodiment of a loosely coupled software evaluation method. See [link to embodiment]. Figure 1 The loosely coupled software evaluation method specifically includes the following: Step S101: Obtain the original evaluation dataset by accessing the operation result data and model calculation result data through the data acquisition interface. Perform outlier detection and missing value imputation on the original evaluation dataset to obtain the cleaned dataset. The cleaned dataset is read by the data conversion module and standardized according to a unified specification to obtain structured evaluation data. Add data lineage information to the structured evaluation data and write it into the data storage area. In this embodiment, job result data and model calculation result data are accessed through data acquisition interfaces. The job result data comes from the offline data source of the business system, while the model calculation result data comes from the online data source of the training system. During the access process, field parsing is performed on the two types of data sources according to preset acquisition rules to extract the field name, field type, and timestamp of each data item. The parsed multi-source heterogeneous data streams are aligned according to the timestamp, and the aligned data entries are merged and written into a temporary buffer to obtain the original evaluation dataset.

[0024] Based on the original evaluation dataset, this embodiment performs outlier detection on each record. The detection process reads the numerical fields of each data record, compares the field values ​​with the historical statistical distribution of that field, and marks the data item as an outlier when the value deviates from the historical mean by a preset threshold. This embodiment compiles the location indices of all outlier records into an outlier tag set, which is used to locate the data items to be processed during subsequent interpolation.

[0025] Accordingly, this embodiment performs interpolation imputation on the missing fields in the anomaly marker set and the original data. The imputation process traverses each index position in the anomaly marker set, reads the valid values ​​of the same field within the adjacent time window of that position, calculates the imputation value using a neighborhood weighting method, and writes it back to the corresponding position. For missing fields, the same neighborhood interpolation strategy is used for imputation. After imputation, the data entries are written to the conversion queue to obtain the cleaned dataset.

[0026] Based on the cleaned dataset, the data transformation module sequentially reads data entries from the transformation queue and performs format standardization according to a unified data transformation specification. The standardization process includes three operations: field mapping, type conversion, and encoding normalization. Field mapping converts the original field names to standard field names using a specification table; type conversion uniformly converts non-standard data types to the target types defined by the specification; and encoding normalization converts the values ​​of categorical fields to numerical codes according to the specification encoding table. After these three operations, the data entries are read by the verification module and undergo format integrity verification. Data entries that pass the verification are marked as structured evaluation data.

[0027] Based on the structured assessment data, this embodiment adds data lineage information. The addition process extracts the data source identifier and collection timestamp from each piece of structured assessment data, and simultaneously reads the current conversion rule version number. These three pieces of information are combined to generate data lineage information and associated with the corresponding structured assessment data. The bound data record carries complete traceability information and is written to the data storage area for reading and use by the visualization modeling environment in subsequent step S201.

[0028] Step S102: Read the structured evaluation data from the data storage area and send it into the visualization modeling environment. Combine operators by dragging and dropping operator primitives to obtain the evaluation calculation model. After the evaluation calculation model is checked for consistency by the operator checking module based on the meta-model rules, it is associated and bound with the evaluation index system to obtain the evaluation scheme configuration. The evaluation scheme configuration is assigned index weight parameters according to the hierarchy and then submitted to the evaluation execution engine. In this embodiment, the structured evaluation data written in step S101 is read from the data storage area. During the reading process, the data is filtered according to the collection timestamp in the data lineage information to obtain data entries within the target evaluation period. After reading, the structured evaluation data is parsed to extract the field name, field type, and value range of each data entry to obtain field description information. The field description information is sent to the visualization modeling environment as a candidate set of operator input parameters.

[0029] In the visual modeling environment, this embodiment combines operators by dragging and dropping operator primitives from a pre-built operator library. The pre-built operator library contains four categories of operator primitives: database operation operators, basic mathematical operation operators, data processing operators, and evaluation method operators. The evaluation method operators cover analytic hierarchy process (AHP) operators, membership function operators, and fuzzy synthesis operators. Users drag and drop the required operator primitives onto the modeling canvas and configure the input and output parameters for each operator. Input parameters are selected from the candidate set of field description information, and output parameters are defined as intermediate calculation results or final index scores.

[0030] Accordingly, this embodiment configures input-output connections between each operator primitive. These connections map the output parameters of the upstream operator to the input parameters of the downstream operator, forming a data flow link between operators. Once all operator primitives have been configured, the modeling environment encapsulates the set of operator primitives and the set of connections into an evaluation calculation model. This evaluation calculation model stores the relationships between operator nodes and edges in a graph structure and is sent to the operator checking module for verification.

[0031] Based on the evaluation calculation model, the operator checking module performs consistency checks on it according to the meta-model rules. The verification process includes two parts: operator parameter type matching verification and operator link integrity verification. The parameter type matching verification compares whether the parameter types at both ends of each connection edge are compatible, and the link integrity verification traverses the graph structure to detect whether there are dangling nodes or circular dependencies. After both verifications pass, the operator checking module outputs a verification result marked as passed, and the evaluation calculation model is sent to the association binding stage.

[0032] Based on the validated evaluation calculation model, this embodiment associates and binds it with the evaluation index system. The evaluation index system organizes index nodes at all levels in a hierarchical tree structure, with each index node corresponding to a capability dimension to be evaluated. The binding process establishes a mapping table according to the semantic correspondence between index nodes and operator outputs, pointing the output parameters of each operator to the corresponding index node. After binding is completed, the evaluation scheme configuration is obtained.

[0033] Based on the evaluation scheme configuration, this embodiment allocates indicator weight parameters hierarchically. The allocation process extracts the hierarchical structure information of the evaluation indicator system from the evaluation scheme configuration, calculates the weight value for each level of indicator node according to a preset weight allocation algorithm, and determines the weight ratio of each node based on the number and importance of indicator nodes at the same level. The calculated weight values ​​are written back to the corresponding indicator nodes in the evaluation scheme configuration to form an indicator weight parameter set. The evaluation scheme configuration carrying the indicator weight parameter set is serialized after integrity verification and submitted to the task queue of the evaluation execution engine for loading and invocation in subsequent step S103.

[0034] Step S103: The evaluation execution engine loads the evaluation scheme configuration and performs layer-by-layer indicator calculation on the structured evaluation data to obtain evaluation result data. The evaluation result data is archived and aggregated according to user identifier and organization identifier to obtain capability file records. The capability file records are correlated with the time sequence of previous evaluations to obtain capability evolution trajectory data. The capability evolution trajectory data is read by the report generation module and the evaluation report document is rendered and output according to the report template.

[0035] In this embodiment, the evaluation execution engine reads the evaluation scheme configuration submitted in step S102 from the task queue. During the reading process, the serialized evaluation scheme configuration is deserialized to parse out the evaluation calculation model and the set of index weight parameters. The evaluation execution engine determines the operator execution order based on the operator nodes and edge relationships in the evaluation calculation model, and arranges the operator nodes into an ordered execution sequence according to the topological sort.

[0036] Based on the execution sequence, the evaluation execution engine performs layer-by-layer index calculations on the structured evaluation data written to the data storage area in step S101. The calculation process sequentially calls each operator node according to the execution sequence. Each operator node reads the corresponding input field from the structured evaluation data, performs the calculation, and outputs intermediate results. These intermediate results are passed to downstream operator nodes as input. After the bottom-level operator nodes complete their calculations, this embodiment aggregates the intermediate results upwards according to the hierarchical structure of the evaluation index system. The calculation results of the index nodes at the same level are weighted and summed according to the corresponding weight values ​​in the set of index weight parameters, and this process is repeated layer by layer upwards until the root node obtains the evaluation result data.

[0037] Accordingly, this embodiment archives and aggregates the evaluation result data according to user identifiers and organization identifiers. The archiving process extracts the user identifier and organization identifier carried in each record from the evaluation result data as archiving index keys. The evaluation result data is then grouped and aggregated according to the user identifier to obtain user-dimensional evaluation records, and grouped and aggregated according to the organization identifier to obtain organization-dimensional evaluation records. The user-dimensional evaluation records and the organization-dimensional evaluation records are merged and written into the capability profile storage area to obtain capability profile records.

[0038] Based on the capability profile records, this embodiment performs a time-series association of previous assessments. The association process retrieves historical capability profile records for the user or organization from the capability profile storage area using the user identifier and organization identifier, obtaining a historical profile sequence. This historical profile sequence is then sorted in ascending order by assessment timestamp. After sorting, this embodiment calculates the difference in indicators between adjacent records, subtracting the corresponding indicator score of the previous record from the current record's indicator score to obtain the indicator change. The indicator scores and indicator changes of each record are combined and encapsulated into capability evolution trajectory data and written to the trajectory data cache.

[0039] Based on the capability evolution trajectory data, the report generation module reads the data from the trajectory data cache and loads a pre-configured report template. The report template defines the report structure in document format, including a title area, an indicator score table area, a capability evolution chart area, and a conclusion area. Placeholder markers and data binding rules are set in each area. The report generation module parses the data binding rules, fills the indicator scores, indicator changes, and evaluation timestamps from the capability evolution trajectory data into the corresponding placeholder positions to obtain the rendered report content, and encapsulates the rendered report content according to the report template format to output an evaluation report document for evaluation users to view and archive.

[0040] As can be seen from the above description, the loosely coupled software evaluation method provided in this application can construct structured evaluation data through unified data access and standardized cleaning, generate evaluation scheme configuration by combining visual drag-and-drop modeling and meta-model consistency verification, and output evaluation report by calculating layer by layer and rendering the capability evolution trajectory through the evaluation execution engine. This effectively solves the shortcomings of traditional technologies in data acquisition and preprocessing, evaluation model construction and configuration, and evaluation execution report output, and provides technical support for the evaluation of loosely coupled architecture of software capabilities and intelligent analysis of the entire process.

[0041] In one embodiment of the loosely coupled software evaluation method of this application, it may further include the following: Step S201: The data acquisition interface reads job result data and model calculation result data from offline data source and online data source respectively according to preset acquisition rules to obtain multi-source heterogeneous data stream. Field parsing and timestamp alignment are performed on the multi-source heterogeneous data stream to obtain the original evaluation dataset. The original evaluation dataset is classified and stored according to data type identifier. Step S202: Read the original evaluation dataset from the classification storage and perform outlier detection on each item. Mark the data items that exceed the preset threshold as outlier records to obtain an outlier mark set. Perform interpolation to fill the outlier mark set and missing fields to obtain the cleaned dataset. The cleaned dataset is written into the conversion queue for the data conversion module to read.

[0042] In this embodiment, the data acquisition interface reads data from both offline and online data sources according to preset acquisition rules. The offline data source stores job result data accumulated over historical periods, while the online data source provides real-time model calculation result data. The data acquisition interface uses a batch pull method to read job result data from offline data sources in batches by file, and uses a streaming subscription method to read model calculation result data from online data sources in message queues. The two types of data are then aggregated to form a multi-source heterogeneous data stream.

[0043] Based on the aforementioned multi-source heterogeneous data stream, this embodiment performs field parsing operations. The parsing process traverses each data record in the data stream, identifies the field name, field type, and field value of each record, and organizes the parsing results according to a unified field description structure. For records from different data sources, this embodiment extracts the original timestamp markers carried by each record and converts them into a unified time base. For records with time base discrepancies, a timestamp alignment operation is performed. The aligned data records are then merged and organized into the original evaluation dataset.

[0044] Accordingly, this embodiment classifies and stores the original evaluation dataset according to data type identifiers. The classification process reads the data type identifier field from each data record, which distinguishes between the job result type and the model calculation result type. In this embodiment, the original evaluation dataset is split into a job result data subset and a model calculation result data subset based on the data type identifiers. The two subsets are written into their respective classification storage areas for subsequent steps S202 to read and process.

[0045] Based on the categorized storage, this embodiment reads the original evaluation dataset from the categorized storage area and performs outlier detection on each record. The detection process calculates the statistical characteristics of the numerical fields of each data record and compares the field values ​​with preset threshold conditions. For example, when the value of a numerical field exceeds the permissible range of fluctuation above or below the historical mean of that field, this embodiment determines that the data item is an anomaly and adds an anomaly marker to the record. After all data records have been detected, this embodiment aggregates the location indices of all records carrying anomaly markers to obtain an anomaly marker set.

[0046] Based on the set of anomaly markers, this embodiment performs interpolation imputation on the missing fields in the original data. The imputation process traverses each index in the set of anomaly markers, locates the anomalous data item in the corresponding data record, reads the valid values ​​of the same field within adjacent time windows for that data item, and calculates the imputation value using a neighborhood-weighted approach. For missing fields present in the original data, this embodiment uses the same neighborhood interpolation strategy for imputation. After both the anomalous data items and missing fields are imputed, this embodiment writes the processed data records into a conversion queue to obtain a cleaned dataset. The cleaned dataset waits in the conversion queue for the data conversion module to read and process in subsequent step S301.

[0047] In one embodiment of the loosely coupled software evaluation method of this application, it may further include the following: Step S301: The data conversion module reads the cleaned dataset from the queue to be converted, performs field mapping, type conversion and encoding normalization on the cleaned dataset according to the unified data conversion specification to obtain structured evaluation data, and the structured evaluation data is read by the verification module and performs format integrity verification. Step S302: Extract the data source identifier, collection timestamp, and conversion rule version from the structured evaluation data that has passed the format integrity check to generate data lineage information. Associate and bind the data lineage information with the structured evaluation data to obtain evaluation data records with lineage tags. Write the evaluation data records with lineage tags into the data storage area.

[0048] In this embodiment, the data conversion module reads the cleaned dataset written in step S202 from the queue to be converted. The reading process retrieves data records in the queue in a first-in, first-out (FIFO) order. The data conversion module loads a pre-configured unified data conversion specification, which defines three conversion components—a field mapping table, type conversion rules, and encoding normalization rules—in the form of a configuration file.

[0049] Based on the cleaned dataset, the data transformation module performs field mapping operations according to a unified data transformation specification. The field mapping process iterates through the original field names of each data record, converting them into standard field names based on the field mapping table. For example, if the original data contains a field named "Task Score," the field mapping table converts it to the standard name "Homework Grade Field," and the converted field name conforms to the unified naming convention.

[0050] Accordingly, the data conversion module performs type conversion operations on the data records for which field mapping has been completed. The type conversion process checks the data type of each field according to type conversion rules, converting non-standard data types to the target type defined by the specification. In this embodiment, text-type numeric fields are converted to floating-point numeric types, and date text fields are converted to timestamp types. The converted field types are consistent with the type definitions of the unified specification.

[0051] Based on the data records after type conversion, the data conversion module performs encoding normalization. The encoding normalization process converts the values ​​of the categorization fields according to encoding normalization rules, transforming the text values ​​of the categorization fields into corresponding numerical codes according to the encoding table. The data records processed by field mapping, type conversion, and encoding normalization are marked as structured evaluation data, which is then sent to the verification module for format integrity verification.

[0052] Based on the structured evaluation data, the verification module performs a format integrity check. The verification process checks whether each data record contains all the required fields defined in the specification, whether the data type of each field is consistent with the specification definition, and whether the values ​​of each field fall within the valid range defined in the specification. Data records that pass the verification are marked as valid records and sent to the subsequent step S302 for processing; data records that fail the verification are written to the exception record queue for manual review.

[0053] Based on the structured evaluation data that has passed the format integrity check, this embodiment extracts data lineage information. The extraction process reads the data source identifier field and the collection timestamp field from each piece of structured evaluation data, and simultaneously reads the currently used conversion rule version number from the data conversion module. This embodiment combines and encapsulates the data source identifier, collection timestamp, and conversion rule version into data lineage information. This data lineage information is then associated and bound with the corresponding structured evaluation data to obtain evaluation data records with lineage tags. These lineage-tagged evaluation data records are written to the data storage area for subsequent reading and retrieval by the visualization modeling environment in step S401.

[0054] In one embodiment of the loosely coupled software evaluation method of this application, it may further include the following: Step S401: Read structured evaluation data from the data storage area and parse the data field structure to obtain field description information. Send the field description information into the visualization modeling environment as a candidate set of operator input parameters. In the visualization modeling environment, obtain the evaluation calculation model by dragging and dropping operator primitives in the preset operator library and configuring the input and output connection relationship between operators. The evaluation calculation model is read by the operator checking module. Step S402: The operator checking module performs operator parameter type matching verification and operator link integrity verification on the evaluation calculation model based on the meta-model rules to obtain the verification result identifier. When the verification result identifier is passed, the evaluation calculation model and the evaluation index system are associated and bound according to the mapping relationship between index nodes and operator outputs to obtain the evaluation scheme configuration.

[0055] This embodiment reads the assessment data records with lineage markers written in step S302 from the data storage area. During the reading process, data entries within the target assessment period are filtered according to the collection timestamp in the data lineage information. After reading, this embodiment performs data field structure parsing on the structured assessment data, traversing each data entry to extract field names, field types, value ranges, and field semantic descriptions to obtain field description information. The field description information is organized in list form and sent to the visualization modeling environment.

[0056] In the visual modeling environment, this embodiment loads the field description information as a candidate set of operator input parameters. During the loading process, each field entry in the field description information is displayed in the parameter selection panel of the modeling interface, allowing the user to select the desired fields from this panel when configuring operator input parameters. The visual modeling environment also loads a pre-built operator library, which includes four types of operator primitives: database operation operators, basic mathematical operation operators, data processing operators, and evaluation method operators.

[0057] Accordingly, this embodiment combines operators by dragging and dropping operator primitives in a visual modeling environment. The user selects the desired operator primitives from a preset operator library and drags them onto the modeling canvas, configuring input and output parameters for each operator primitive on the canvas. Input parameters are selected from the candidate set of the field description information, while output parameters are defined by the user as intermediate calculation variables or final index scores. After configuration, the user draws connecting lines between operator primitives to establish input-output connections. These connecting lines map the output parameters of upstream operators to the input parameters of downstream operators, forming a data flow link.

[0058] After all operator primitives have been configured for connectivity, the visual modeling environment encapsulates the set of operator primitives and the set of connectivity relationships into an evaluation computation model. This evaluation computation model is stored in a directed graph structure, where nodes represent operator primitives and edges represent input-output connectivity relationships between operators. In this embodiment, the evaluation computation model is sent to the operator checking module for consistency verification in subsequent step S402.

[0059] Based on the evaluation calculation model, the operator checking module performs operator parameter type matching verification based on meta-model rules. The verification process traverses each connection edge in the evaluation calculation model, reads and compares the parameter type definitions of the operators at both ends of the connection edge, and marks the connection edge as type mismatched when the output parameter type of the upstream operator is incompatible with the input parameter type of the downstream operator. The operator checking module also performs operator link integrity verification on the evaluation calculation model, checking for dangling nodes with zero in-degree but not data sources, and detecting circular dependency paths forming closed loops.

[0060] Accordingly, the operator checking module outputs a verification result identifier based on the results of the above two checks. When no abnormalities are found in both the parameter type matching check and the link integrity check, the verification result identifier is set to a passed state. When the verification result identifier is passed, this embodiment associates and binds the evaluation calculation model with the evaluation index system. The evaluation index system organizes the index nodes at each level in a hierarchical tree structure. The binding process establishes a mapping relationship table between index nodes and operator outputs, pointing the output parameters of each operator to the semantically corresponding index nodes. After the binding is completed, the evaluation scheme configuration is obtained for subsequent steps S501 to read and process.

[0061] In one embodiment of the loosely coupled software evaluation method of this application, it may further include the following: Step S501: Extract the hierarchical structure information of the evaluation index system from the evaluation scheme configuration, calculate the weight value of each level index node according to the hierarchical structure information and the preset weight allocation algorithm to obtain the index weight parameter set, and write the index weight parameter set back to the corresponding index node in the evaluation scheme configuration. Step S502: Perform an integrity check on the evaluation scheme configuration carrying the set of indicator weight parameters to obtain the scheme check result. When the scheme check result is passed, serialize the evaluation scheme configuration and submit it to the task queue of the evaluation execution engine.

[0062] This embodiment extracts the hierarchical structure information of the evaluation index system from the evaluation scheme configuration output in step S402. The extraction process traverses the hierarchical tree structure of the evaluation index system, reading the number of index nodes, node identifiers, and parent-child relationships at each level to obtain the hierarchical structure information. The hierarchical structure information is organized in a tree-like description structure, recording the complete hierarchical path from the root node to each leaf node.

[0063] Based on the hierarchical structure information, this embodiment calculates the weight values ​​for each level of indicator nodes according to a preset weight allocation algorithm. The weight allocation algorithm processes upwards layer by layer from the leaf node level of the hierarchical tree, determining the weight ratio for each child node under the same parent node based on its importance ranking and the number of nodes. For example, when a parent node has three child nodes with the same importance ranking, the weight allocation algorithm assigns an equal weight ratio to each child node, and the sum of the weight values ​​of all child nodes equals the weight value of their parent node.

[0064] Accordingly, this embodiment calculates the weights of the indicator nodes at each level sequentially from bottom to top. During the calculation process, weight allocation is performed on the indicator nodes at each level, and the allocation results are temporarily stored in the weight calculation cache. After all levels have completed the weight calculation, this embodiment gathers the weight values ​​of each indicator node from the weight calculation cache to obtain an indicator weight parameter set. This indicator weight parameter set is organized in key-value pairs of node identifiers and weight values.

[0065] Based on the set of indicator weight parameters, this embodiment writes them back to the corresponding indicator nodes in the evaluation scheme configuration. The write-back process iterates through each key-value pair in the set of indicator weight parameters, locates the corresponding indicator node in the evaluation indicator system of the evaluation scheme configuration based on the node identifier, and writes the weight value into the weight parameter field of that indicator node. After the write-back is completed, each indicator node in the evaluation scheme configuration carries the corresponding weight parameter value.

[0066] Based on the evaluation scheme configuration carrying the set of indicator weight parameters, this embodiment performs a completeness check to obtain the scheme verification result. The verification process checks whether the evaluation scheme configuration contains three items: a complete evaluation calculation model, an evaluation indicator system, and a set of indicator weight parameters; whether each indicator node has been bound to the corresponding operator output; and whether the weight parameter fields of each indicator node have been filled with valid values. When all the above checks pass, the scheme verification result is set to a passed state.

[0067] When the scheme verification result is passed, this embodiment serializes the evaluation scheme configuration and submits it to the task queue of the evaluation execution engine. The serialization process converts the data structure of the evaluation scheme configuration into a transmittable byte sequence format. The serialized evaluation scheme configuration is written into the task queue of the evaluation execution engine to await scheduling and execution, for loading and processing by the evaluation execution engine in subsequent step S601.

[0068] In one embodiment of the loosely coupled software evaluation method of this application, it may further include the following: Step S601: The evaluation execution engine reads the evaluation scheme configuration from the task queue and parses the evaluation calculation model and the set of indicator weight parameters. It performs layer-by-layer indicator calculation on the structured evaluation data according to the operator execution order defined by the evaluation calculation model. The evaluation result data is obtained by weighting and summarizing the calculation results of each level of indicators according to the set of indicator weight parameters. Step S602: Extract the user identifier and organization identifier from the evaluation result data as archive index keys, perform grouping and aggregation on the evaluation result data according to the archive index keys to obtain user dimension evaluation records and organization dimension evaluation records, and merge the user dimension evaluation records and organization dimension evaluation records into the capability file storage area to obtain capability file records.

[0069] In this embodiment, the evaluation execution engine reads the serialized evaluation scheme configuration submitted in step S502 from the task queue. The reading process retrieves the evaluation scheme configurations to be processed according to the scheduling order of the task queue, and performs deserialization on the serialized byte sequence to restore it to a data structure form. The evaluation execution engine parses the evaluation calculation model and the set of indicator weight parameters from the restored evaluation scheme configuration. The evaluation calculation model stores operator nodes and connection relationships in a directed graph structure, and the set of indicator weight parameters stores the weight parameters of each indicator node in key-value pairs of node identifiers and weight values.

[0070] Based on the evaluation computation model, the evaluation execution engine determines the operator execution order. The process of determining the execution order involves performing a topological sort on the directed graph structure of the evaluation computation model, arranging each operator node sequentially starting from the data source operator node with an in-degree of zero. This arrangement ensures that all upstream operator nodes of each operator node have completed their computations before execution. After the sorting is complete, the evaluation execution engine obtains the operator execution sequence for subsequent layer-by-layer index calculations.

[0071] Accordingly, the evaluation execution engine performs layer-by-layer index calculations on the structured evaluation data written to the data storage area in step S302 according to the operator execution sequence. The calculation process sequentially calls each operator node in the execution sequence. Each operator node reads the corresponding input field from the structured evaluation data or receives intermediate calculation results from upstream operator nodes, performs the calculation according to the operator's defined operational logic, and outputs the result. The output results of the lower-level operator nodes are passed to the upper-level operator nodes as input, completing the calculation of each level of index layer by layer upwards.

[0072] After the calculation of indicators at each level is completed, this embodiment performs a weighted summary of the calculation results according to the set of indicator weight parameters. The summary process reads the weight value corresponding to each indicator node from the set of indicator weight parameters, multiplies the indicator calculation results of each child node under the same parent node by the corresponding weight value, and then sums the results. The sum is used as the indicator score for that parent node. The weighted summary is performed hierarchically from bottom to top until the root node. The indicator score of the root node, together with the indicator scores of each level, constitutes the evaluation result data.

[0073] Based on the evaluation result data, this embodiment extracts user identifiers and organization identifiers as archival index keys. The extraction process reads the user identifier and organization identifier fields from each record in the evaluation result data. The user identifier is associated with the individual user participating in the evaluation, and the organization identifier is associated with the user's unit or class. This embodiment uses the user identifier and organization identifier as two separate archival index keys for subsequent grouping and aggregation operations.

[0074] Accordingly, this embodiment performs grouping and aggregation on the evaluation result data according to the archive index key. The grouping and aggregation process groups the evaluation result data by user identifier, aggregating each evaluation record under the same user identifier into a user-dimensional evaluation record. Simultaneously, the grouping and aggregation process groups the evaluation result data by organization identifier, aggregating each evaluation record under the same organization identifier and calculating the overall organization indicator score to obtain an organization-dimensional evaluation record. This embodiment merges the user-dimensional evaluation record and the organization-dimensional evaluation record and writes them into the capability archive storage area to obtain a capability archive record. This capability archive record is used by the subsequent step S701 to perform sequential association of previous evaluations.

[0075] In one embodiment of the loosely coupled software evaluation method of this application, it may further include the following: Step S701: Retrieve historical capability archive records from the capability archive storage area by user identifier and organization identifier to obtain historical archive sequence, sort the historical archive sequence by evaluation timestamp and perform index difference calculation between adjacent records to obtain capability evolution trajectory data, and write the capability evolution trajectory data into trajectory data cache area. Step S702: The report generation module reads the capability evolution trajectory data from the trajectory data cache and parses the placeholders and data binding rules in the report template. According to the data binding rules, the capability evolution trajectory data is filled into the corresponding placeholder positions to obtain the rendered report content. The rendered report content is then packaged and output as an evaluation report document according to the report template format.

[0076] This embodiment retrieves capability profile records written in step S602 from the capability profile storage area by user identifier and organization identifier. The retrieval process receives the user identifier or organization identifier to be queried as the search criteria, traverses all capability profile records in the capability profile storage area, and filters out record entries that match the search criteria. When searching by user identifier, the capability profile records formed by the user in previous evaluations are returned; when searching by organization identifier, the capability profile records formed by the organization in previous evaluations are returned. The search results are organized into a historical profile sequence.

[0077] Based on the historical archive sequence, this embodiment sorts it according to the assessment timestamp. The sorting process reads the assessment timestamp field carried by each capability archive record in the historical archive sequence and arranges them in ascending order from earliest to latest timestamp value. After sorting, the records in the historical archive sequence are arranged in chronological order according to the time when the assessment occurred, forming a chronologically ordered archive record sequence.

[0078] Accordingly, this embodiment performs index difference calculation on the sorted historical archive sequence. The difference calculation process reads two adjacent capability archive records sequentially from the sequence, subtracts the corresponding index score of the previous record from the index score of the subsequent record to obtain the index change. For example, when a user's performance index score in the previous assessment is a specific value and the index score changes in the current assessment, the difference calculation outputs the change value of that index. This embodiment combines and encapsulates the index scores of each capability archive record, the assessment timestamp, and the index change between adjacent records into capability evolution trajectory data.

[0079] Based on the capability evolution trajectory data, this embodiment writes it into the trajectory data cache. The writing process uses the user identifier or organization identifier as the cache key to store the corresponding capability evolution trajectory data in the trajectory data cache. The trajectory data cache adopts a memory cache structure to support fast read access by the report generation module.

[0080] Based on the trajectory data cache, the report generation module reads the capability evolution trajectory data and loads a pre-configured report template. The report template defines the overall structure of the assessment report in document format, including a title area, a basic information area, an indicator score table area, a capability evolution chart area, and an assessment conclusion area. Placeholders are set in each area to identify the location of data to be filled, and data binding rules are configured to specify the correspondence between each placeholder and a field in the capability evolution trajectory data.

[0081] Accordingly, the report generation module parses the placeholders and data binding rules in the report template. The parsing process traverses each placeholder marker in the report template, reads the data binding rule associated with each placeholder to determine the data field that should be filled in at that position. The report generation module extracts the corresponding field values ​​from the capability evolution trajectory data according to the data binding rules, and fills the indicator score, indicator change, evaluation timestamp, and user or organization identifier into the corresponding placeholder position to obtain the rendered report content.

[0082] Based on the rendered report content, the report generation module encapsulates and outputs it according to the report template format. The encapsulation process converts the rendered report content into the target document type according to the document format defined in the report template, generating an assessment report document containing complete evaluation information and capability evolution analysis. This assessment report document is output to a designated storage path for evaluation users to view and archive, completing the entire evaluation process of this embodiment.

[0083] To effectively address the shortcomings of traditional technologies in data acquisition and preprocessing, evaluation model construction and configuration, and evaluation execution report output, and to provide technical support for the evaluation of loosely coupled software capabilities and intelligent analysis throughout the entire process, this application provides an embodiment of a loosely coupled software evaluation device for implementing all or part of the aforementioned loosely coupled software evaluation method. See [link to embodiment]. Figure 2 The loosely coupled software evaluation device specifically includes the following components: The data acquisition module 10 is used to obtain the original evaluation dataset by accessing the operation result data and model calculation result data through the data acquisition interface, perform outlier detection and missing value imputation on the original evaluation dataset to obtain the cleaned dataset, the cleaned dataset is read by the data conversion module and standardized according to a unified specification to obtain structured evaluation data, and the structured evaluation data is written into the data storage area after adding data lineage information. The operator acquisition module 20 is used to read the structured evaluation data from the data storage area and send it into the visualization modeling environment. It obtains the evaluation calculation model by dragging and dropping operator primitives to combine operators. After the evaluation calculation model is verified by the operator checking module based on the meta-model rules, it is associated and bound with the evaluation index system to obtain the evaluation scheme configuration. The evaluation scheme configuration is assigned index weight parameters according to the hierarchy and then submitted to the evaluation execution engine. The software evaluation module 30 is used by the evaluation execution engine to load the evaluation scheme configuration and perform layer-by-layer indicator calculation on the structured evaluation data to obtain evaluation result data. The evaluation result data is archived and aggregated according to user identifier and organization identifier to obtain capability file records. The capability file records are correlated with the time sequence of previous evaluations to obtain capability evolution trajectory data. The capability evolution trajectory data is read by the report generation module and rendered and outputs an evaluation report document according to the report template.

[0084] As can be seen from the above description, the loosely coupled software evaluation device provided in this application embodiment can construct structured evaluation data through unified data access and standardized cleaning, generate evaluation scheme configuration by combining visual drag-and-drop modeling and meta-model consistency verification, and output evaluation report through layer-by-layer calculation and capability evolution trajectory correlation rendering through evaluation execution engine. It effectively solves the shortcomings of traditional technologies in data acquisition and preprocessing, evaluation model construction and configuration, and evaluation execution report output, and provides technical support for the evaluation of loosely coupled architecture of software capabilities and intelligent analysis of the whole process.

[0085] This invention also provides a computer device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor performs the loosely coupled software evaluation method.

[0086] This invention also provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the aforementioned loosely coupled software evaluation method.

[0087] This invention also provides a computer program product, which includes a computer program that, when executed by a processor, implements the above-described loosely coupled software evaluation method.

[0088] In this embodiment of the invention, structured evaluation data is constructed through unified data access and standardized cleaning. Evaluation scheme configuration is generated by combining visual drag-and-drop modeling and meta-model consistency verification. Evaluation reports are output by performing layer-by-layer calculations and rendering associated with capability evolution trajectories through the evaluation execution engine. This effectively solves the shortcomings of traditional technologies in data acquisition and preprocessing, evaluation model construction and configuration, and evaluation execution report output, and provides technical support for the evaluation of loosely coupled architecture of software capabilities and intelligent analysis of the entire process.

[0089] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, systems, or computer program products. Therefore, the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0090] This invention is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart illustrations and / or block diagrams. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0091] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0092] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0093] The specific embodiments described above further illustrate the purpose, technical solution, and beneficial effects of the present invention. It should be understood that the above descriptions are merely specific embodiments of the present invention and are not intended to limit the scope of protection of the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A loosely coupled software evaluation method, characterized in that, The method includes: The original evaluation dataset is obtained by accessing the operation result data and model calculation result data through the data acquisition interface. The original evaluation dataset is then subjected to outlier detection and missing value imputation to obtain a cleaned dataset. The cleaned dataset is read by the data conversion module and standardized according to a unified specification to obtain structured evaluation data. The structured evaluation data is then written into the data storage area after adding data lineage information. The structured evaluation data is read from the data storage area and sent to the visualization modeling environment. The evaluation calculation model is obtained by dragging and dropping operator primitives to combine operators. The evaluation calculation model is then verified for consistency by the operator checking module based on the meta-model rules and associated with the evaluation index system to obtain the evaluation scheme configuration. The evaluation scheme configuration is then assigned index weight parameters according to the hierarchy and submitted to the evaluation execution engine. The evaluation execution engine loads the evaluation scheme configuration and performs layer-by-layer indicator calculation on the structured evaluation data to obtain evaluation result data. The evaluation result data is archived and aggregated according to user identifier and organization identifier to obtain capability archive records. The capability archive records are correlated with the time sequence of previous evaluations to obtain capability evolution trajectory data. The capability evolution trajectory data is read by the report generation module and rendered and outputs an evaluation report document according to the report template.

2. The weakly coupled software evaluation method according to claim 1, characterized in that, The process involves accessing job result data and model calculation result data through a data acquisition interface to obtain the original evaluation dataset. Outlier detection and missing value imputation are then performed on the original evaluation dataset to obtain a cleaned dataset, including: The data acquisition interface reads job result data and model calculation result data from offline data sources and online data sources respectively according to preset acquisition rules to obtain a multi-source heterogeneous data stream. Field parsing and timestamp alignment are performed on the multi-source heterogeneous data stream to obtain the original evaluation dataset. The original evaluation dataset is classified and stored according to data type identifier. The original evaluation dataset is read from the classification storage and outlier detection is performed on each item. Data items that exceed the preset threshold are marked as outlier records to obtain an outlier mark set. The outlier mark set and missing fields are interpolated to obtain the cleaned dataset. The cleaned dataset is written to the conversion queue for the data conversion module to read.

3. The weakly coupled software evaluation method according to claim 1, characterized in that, The cleaned dataset is read by the data conversion module and standardized according to a unified specification to obtain structured evaluation data. After appending data lineage information to the structured evaluation data, it is written into the data storage area, including: The data conversion module reads the cleaned dataset from the queue to be converted, performs field mapping, type conversion and encoding normalization on the cleaned dataset according to the unified data conversion specification to obtain structured evaluation data, and the structured evaluation data is read by the verification module and performs format integrity verification. Data source identifier, collection timestamp, and conversion rule version are extracted from the structured evaluation data that has passed the format integrity check to generate data lineage information. The data lineage information is associated and bound with the structured evaluation data to obtain evaluation data records with lineage tags. The evaluation data records with lineage tags are written into the data storage area.

4. The weakly coupled software evaluation method according to claim 1, characterized in that, The process involves reading the structured evaluation data from the data storage area and sending it into the visualization modeling environment. An evaluation calculation model is obtained by dragging and dropping operator primitives to combine operators. After the evaluation calculation model undergoes consistency verification based on meta-model rules by the operator checking module, it is associated and bound with the evaluation index system to obtain the evaluation scheme configuration, including: The structured evaluation data is read from the data storage area and the data field structure is parsed to obtain field description information. The field description information is sent to the visualization modeling environment as a candidate set of operator input parameters. In the visualization modeling environment, the evaluation calculation model is obtained by dragging and dropping operator primitives in the preset operator library and configuring the input and output connection relationship between operators. The evaluation calculation model is read by the operator checking module. The operator checking module performs operator parameter type matching verification and operator link integrity verification on the evaluation calculation model based on meta-model rules to obtain a verification result identifier. When the verification result identifier is passed, the evaluation calculation model and the evaluation index system are associated and bound according to the mapping relationship between index nodes and operator outputs to obtain the evaluation scheme configuration.

5. The weakly coupled software evaluation method according to claim 1, characterized in that, The step of configuring the evaluation scheme with hierarchical allocation of indicator weight parameters and submitting it to the evaluation execution engine includes: Extract the hierarchical structure information of the evaluation index system from the evaluation scheme configuration, calculate the weight value of each level index node based on the hierarchical structure information according to the preset weight allocation algorithm to obtain the index weight parameter set, and write the index weight parameter set back to the corresponding index node in the evaluation scheme configuration. An integrity check is performed on the evaluation scheme configuration carrying the set of indicator weight parameters to obtain the scheme check result. When the scheme check result is passed, the evaluation scheme configuration is serialized and submitted to the task queue of the evaluation execution engine.

6. The weakly coupled software evaluation method according to claim 1, characterized in that, The evaluation execution engine loads the evaluation scheme configuration and performs layer-by-layer indicator calculations on the structured evaluation data to obtain evaluation result data. The evaluation result data is then archived and aggregated according to user and organization identifiers to obtain capability profile records, including: The evaluation execution engine reads the evaluation scheme configuration from the task queue and parses the evaluation calculation model and indicator weight parameter set. It performs layer-by-layer indicator calculation on the structured evaluation data according to the operator execution order defined by the evaluation calculation model. The evaluation result data is obtained by weighting and summarizing the indicator calculation results of each level according to the indicator weight parameter set. The user identifier and organization identifier are extracted from the evaluation result data as archive index keys. The evaluation result data is then grouped and aggregated according to the archive index keys to obtain user dimension evaluation records and organization dimension evaluation records. The user dimension evaluation records and organization dimension evaluation records are then merged and written into the capability file storage area to obtain capability file records.

7. The weakly coupled software evaluation method according to claim 1, characterized in that, The capability evolution trajectory data is obtained by performing a time-series correlation analysis on the capability profile records. This capability evolution trajectory data is read by the report generation module and, based on a report template, renders and outputs an assessment report document, including: The historical archive sequence is obtained by retrieving historical capability archive records from the capability archive storage area according to user identifier and organization identifier. The historical archive sequence is sorted according to the evaluation timestamp and the index difference between adjacent records is calculated to obtain capability evolution trajectory data. The capability evolution trajectory data is written into the trajectory data cache area. The report generation module reads the capability evolution trajectory data from the trajectory data cache and parses the placeholders and data binding rules in the report template. According to the data binding rules, it fills the capability evolution trajectory data into the corresponding placeholder positions to obtain the rendered report content. The rendered report content is then packaged and output as an evaluation report document according to the report template format.

8. A loosely coupled software evaluation device, characterized in that, The device includes: The data acquisition module is used to obtain the original evaluation dataset by accessing the operation result data and model calculation result data through the data acquisition interface, perform outlier detection and missing value imputation on the original evaluation dataset to obtain the cleaned dataset, the cleaned dataset is read by the data conversion module and standardized according to a unified specification to obtain structured evaluation data, and the structured evaluation data is written into the data storage area after adding data lineage information. The operator acquisition module is used to read the structured evaluation data from the data storage area and send it into the visualization modeling environment. The evaluation calculation model is obtained by dragging and dropping operator primitives to combine operators. The evaluation calculation model is then verified by the operator checking module based on the meta-model rules and associated with the evaluation index system to obtain the evaluation scheme configuration. The evaluation scheme configuration is then assigned index weight parameters according to the hierarchy and submitted to the evaluation execution engine. The software evaluation module is used by the evaluation execution engine to load the evaluation scheme configuration and perform layer-by-layer indicator calculation on the structured evaluation data to obtain evaluation result data. The evaluation result data is archived and aggregated according to user identifier and organization identifier to obtain capability file records. The capability file records are correlated with the time sequence of previous evaluations to obtain capability evolution trajectory data. The capability evolution trajectory data is read by the report generation module and rendered and outputs an evaluation report document according to the report template.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the program, it implements the steps of the weakly coupled software evaluation method according to any one of claims 1 to 7.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When executed by a processor, the computer program implements the steps of the loosely coupled software evaluation method according to any one of claims 1 to 7.

Images