Method and system for evaluating software function points based on large models

Abstract

This invention relates to the field of information processing technology and discloses a method and system for evaluating software function points based on a large model. The method includes: preprocessing text data from a pre-set enterprise R&D efficiency training library to obtain a preprocessed corpus; initializing the model parameters of a pre-trained model; inputting the labeled dataset from the corpus into the pre-trained model for iterative training to obtain a trained target model; inputting the test dataset corresponding to the function points of the software under test into the target model for calculation to obtain function point size estimation parameters and enterprise production efficiency parameters; and calculating the estimated cost of the software under test based on the function point size estimation parameters, enterprise production efficiency parameters, and a pre-set cost estimation algorithm. Therefore, implementing this invention can unify the process and quantification standards for enterprise software cost estimation, improve the applicability of software cost estimation schemes, and thus improve the efficiency and accuracy of software cost assessment.

Description

Technical Field

[0001] This invention relates to the field of information processing technology, and in particular to a method and system for evaluating software function points based on a large model. Background Technology

[0002] Currently, traditional software cost estimation methods typically calculate the final cost based on the scale of the functionalities of the evaluated object, industry average production efficiency, and regional average labor costs. However, this method often has the following shortcomings:

[0003] First, industry average production efficiency and regional average labor costs are statistical data, which differ significantly from the data of individual companies and often do not have high reference value, especially for small and micro enterprises and large enterprises.

[0004] Secondly, traditional software cost estimation methods only consider the software being evaluated itself in terms of reusability, without taking into account whether the company has undertaken similar projects or accumulated similar controls, components, or core product line resources. Therefore, using traditional estimation methods, the estimated costs will be lower than the actual production costs when the upgrade project is undertaken by different vendors, and higher than the estimated costs for companies with abundant resources. Furthermore, companies cannot accurately assess their actual production costs.

[0005] Furthermore, traditional software cost estimation methods often fail to consider the compatibility between the development language, technical approach, and the company's own technological reserves. When the specific development language or technical approach required for the project does not match the company's technological reserves, traditional estimation methods produce significant cost discrepancies. Moreover, the manual assessment process is slow, resulting in low efficiency and accuracy when dealing with large-scale or complex software projects.

[0006] Therefore, a software function point evaluation method and system based on a large model is provided, which can unify the process and quantitative standards of enterprise software cost estimation, improve the applicability of software cost estimation schemes, realize the intelligence and automation of software cost calculation, and thus help improve the efficiency and accuracy of software cost evaluation. Summary of the Invention

[0007] This invention provides a method and system for evaluating software function points based on a large model, which can standardize the process and methods of enterprise software cost estimation, improve the applicability of software cost estimation schemes, and thus help improve the efficiency and accuracy of software cost assessment.

[0008] To address the aforementioned technical problems, the first aspect of this invention discloses a software function point evaluation method based on a large model, the method comprising:

[0009] The text data in the preset enterprise R&D efficiency training library is preprocessed to obtain a preprocessed corpus. The corpus includes at least a labeled dataset corresponding to the software function points with labeled evaluation parameters.

[0010] The model parameters of the pre-trained model are initialized, and the labeled dataset in the corpus is input into the pre-trained model for iterative training to obtain the trained target model;

[0011] The dataset corresponding to the function points of the software under test is input into the target model for calculation to obtain the function point size estimation parameters and enterprise production efficiency parameters.

[0012] The estimated cost of the software under test is calculated based on the function point scale estimation parameters, the enterprise production efficiency parameters, the enterprise cost parameters, and the preset cost estimation algorithm.

[0013] As an optional implementation, in the first aspect of the present invention, the enterprise R&D efficiency training library includes at least one of the following: enterprise human resources data, enterprise revenue and expenditure data, historical project requirement data, historical project technical route data, and historical project development architecture data; the labeled dataset includes multiple texts and / or words and / or phrases used to describe the software function points; and the preprocessing operation includes at least one of the following: data cleaning, data filtering, data transformation, and data normalization processing.

[0014] Before initializing the model parameters of the pre-trained model, the method further includes:

[0015] The loss function of the pre-trained model is constructed based on the text and / or words and / or phrases in the corpus.

[0016] The formula for calculating the loss function is as follows:

[0017]

[0018]

[0019] Wherein, the coppus refers to the predictive library comprising multiple texts and / or words and / or phrases for describing the software functionalities. Let p represent the loss function, and let p represent the probability function. Represented as the nth character, word, or phrase in the corpus, the The number of tokens in the corpus is represented by the number of tokens in the corpus. Represented as GPT model parameters;

[0020] And, after initializing the model parameters of the pre-trained model, the method further includes:

[0021] Freeze some model parameters of the pre-trained model according to preset freeze parameters.

[0022] As an optional implementation, in the first aspect of the present invention, after preprocessing the text data in the preset enterprise R&D efficiency training library to obtain the preprocessed corpus, the method further includes:

[0023] Based on the semantic type matching the text data corresponding to each software function point in the corpus, semantic type annotation is performed on the text data corresponding to each software function point; and / or,

[0024] Based on the syntax type that matches the text data corresponding to each software function point in the corpus, the text data corresponding to each software function point is annotated with syntax type.

[0025] Furthermore, based on preset evaluation parameters, evaluation parameters that match the text data corresponding to each software function point are determined, thereby obtaining an annotated dataset corresponding to the software function points annotated with the evaluation parameters.

[0026] The evaluation parameters include at least one of the following: development benefit level, development cost level, development scale level, and complexity level, which are matched with the text data corresponding to each software function point.

[0027] As an optional implementation, in the first aspect of the present invention, the pre-trained model is represented as a sequence-to-sequence neural network model based on a self-attention mechanism, and the model parameters of the pre-trained model include at least a self-attention layer, a multi-head attention layer, and a feedforward neural network layer.

[0028] The self-attention layer comprises: an input sequence, a query, a key, a value, attention weights, and an output layer. The input sequence of the self-attention layer is represented as follows: The parameter of the input sequence is the coppus, and i represents the i-th element of the input sequence;

[0029] The linear transformation calculation formula for the query, the key, and the value is as follows:

[0030]

[0031] The formula for calculating the attention weight is:

[0032]

[0033] The calculation formula for the output layer is:

[0034]

[0035] Wherein, Q represents the query, K represents the key, and V represents the value. Represented as a query weight matrix, the Represented as a key weight matrix, the It is represented as a value weight matrix, where attention represents the attention weights, d represents the dimension, and output represents the output parameters;

[0036] The multi-head attention layer includes: the input sequence, the head, the attention weights of the head, and the output layer;

[0037] The formula for calculating the attention weight for each head is:

[0038]

[0039] The calculation formula for the output layer is:

[0040]

[0041] Among them, the Let represent the i-th head of the multi-head attention, h represent the number of heads, selfAttention represent the self-attention mechanism function, WO represent the linear transformation corresponding to the output layer of the self-attention layer, and multihead_attention represent the output parameters of the multi-head attention layer;

[0042] The feedforward neural network layer includes at least: an input layer, a hidden layer, and an output layer.

[0043] As an optional implementation, in the first aspect of the present invention, the step of inputting the labeled dataset from the corpus into the pre-trained model for iterative training to obtain the trained target model includes:

[0044] The labeled dataset from the corpus is input into the pre-trained model for iterative training to obtain the trained model.

[0045] Determine whether the trained model tends to converge based on the loss function of the pre-trained model;

[0046] When it is determined that the trained model has not converged, the model parameters are updated according to the gradient of the loss function and through an optimization algorithm, and the iterative training operation is repeated on the trained model.

[0047] When it is determined that the trained model tends to converge, the iterative training operation is stopped, and the final target model is obtained.

[0048] As an optional implementation, in the first aspect of the present invention, the optimization algorithm includes one of: gradient descent, stochastic gradient descent, mini-batch gradient descent, Adam, RMSProp, momentum, and AdaGrad;

[0049] The preset cost estimation algorithm is expressed as follows:

[0050] .

[0051] As an optional implementation, in the first aspect of the present invention, the enterprise production efficiency parameter includes at least one of the following: reuse coefficient, complexity coefficient, industry coefficient, and cost coefficient;

[0052] The step of inputting the dataset corresponding to the function points of the software under test into the target model for calculation to obtain function point size estimation parameters and enterprise production efficiency parameters includes:

[0053] The dataset corresponding to the function points of the software under test is input into the target model for calculation to obtain the function point size estimation parameters and historical project feature parameters.

[0054] Enterprise production efficiency parameters are generated based on the function point size estimation parameters and historical project characteristic parameters.

[0055] A second aspect of this invention discloses a software function point evaluation system based on a large model, the system comprising:

[0056] The preprocessing module is used to preprocess the text data in the preset enterprise R&D efficiency training library to obtain a preprocessed corpus. The corpus includes at least the labeled dataset corresponding to the software function points with labeled evaluation parameters.

[0057] The initialization module is used to initialize the model parameters of the pre-trained model;

[0058] The training module is used to input the labeled dataset from the corpus obtained by the preprocessing module into the pre-trained model initialized by the initialization module for iterative training to obtain the trained target model.

[0059] The calculation module is used to input the test dataset corresponding to the function points of the software under test into the target model trained by the training module for calculation, to obtain function point size estimation parameters and enterprise production efficiency parameters; and to calculate the estimated cost of the software under test based on the function point size estimation parameters, the enterprise production efficiency parameters, the enterprise cost parameters and the preset cost estimation algorithm.

[0060] As an optional implementation, in the second aspect of the present invention, the enterprise R&D efficiency training library includes at least one of the following: enterprise human resources data, enterprise revenue and expenditure data, historical project requirement data, historical project technical route data, and historical project development architecture data; the labeled dataset includes multiple texts and / or words and / or short sentences used to describe the software function points; and the preprocessing operation includes at least one of the following: data cleaning, data filtering, data transformation, and data normalization processing.

[0061] The system also includes:

[0062] The construction module is used to construct the loss function of the pre-trained model based on the text and / or words and / or phrases in the corpus before the initialization module initializes the model parameters of the pre-trained model.

[0063] The formula for calculating the loss function is as follows:

[0064]

[0065]

[0066] Wherein, the coppus refers to the predictive library comprising multiple texts and / or words and / or phrases for describing the software functionalities. Let p represent the loss function, and let p represent the probability function. Represented as the nth character, word, or phrase in the corpus, the The number of tokens in the corpus is represented by the number of tokens in the corpus. Represented as GPT model parameters;

[0067] And a freeze module, used to freeze some of the model parameters of the pre-trained model according to preset freeze parameters after the initialization module initializes the model parameters of the pre-trained model.

[0068] As an optional implementation, in a second aspect of the invention, the system further includes:

[0069] The annotation module is used to perform preprocessing operations on the text data in the preset enterprise R&D efficiency training library in the preprocessing module to obtain a preprocessed corpus, and then to perform semantic type annotation on the text data corresponding to each software function point according to the semantic type that matches the text data corresponding to each software function point in the corpus; and / or, to perform grammatical type annotation on the text data corresponding to each software function point according to the grammatical type that matches the text data corresponding to each software function point; and to determine the evaluation parameters that match the text data corresponding to each software function point according to preset evaluation parameters, so as to obtain the annotated dataset corresponding to the software function points annotated with the evaluation parameters.

[0070] The evaluation parameters include at least one of the following: development benefit level, development cost level, development scale level, and complexity level, which are matched with the text data corresponding to each software function point.

[0071] As an optional implementation, in a second aspect of the present invention, the pre-trained model is represented as a sequence-to-sequence neural network model based on a self-attention mechanism, and the model parameters of the pre-trained model include at least a self-attention layer, a multi-head attention layer, and a feedforward neural network layer.

[0072] The self-attention layer comprises: an input sequence, a query, a key, a value, attention weights, and an output layer. The input sequence of the self-attention layer is represented as follows: The parameter of the input sequence is the coppus, and i represents the i-th element of the input sequence;

[0073] The linear transformation calculation formula for the query, the key, and the value is as follows:

[0074]

[0075] The formula for calculating the attention weight is:

[0076]

[0077] The calculation formula for the output layer is:

[0078]

[0079] Wherein, Q represents the query, K represents the key, and V represents the value. Represented as a query weight matrix, the Represented as a key weight matrix, the It is represented as a value weight matrix, where attention represents the attention weights, d represents the dimension, and output represents the output parameters;

[0080] The multi-head attention layer includes: the input sequence, the head, the attention weights of the head, and the output layer;

[0081] The formula for calculating the attention weight for each head is:

[0082]

[0083] The calculation formula for the output layer is:

[0084]

[0085] Among them, the Let represent the i-th head of the multi-head attention, h represent the number of heads, selfAttention represent the self-attention mechanism function, WO represent the linear transformation corresponding to the output layer of the self-attention layer, and multihead_attention represent the output parameters of the multi-head attention layer;

[0086] The feedforward neural network layer includes at least: an input layer, a hidden layer, and an output layer.

[0087] As an optional implementation, in the second aspect of the present invention, the training module inputs the labeled dataset from the corpus into the pre-trained model for iterative training to obtain the trained target model in the following specific manner:

[0088] The labeled dataset from the corpus is input into the pre-trained model for iterative training to obtain the trained model.

[0089] Determine whether the trained model tends to converge based on the loss function of the pre-trained model;

[0090] When it is determined that the trained model has not converged, the model parameters are updated according to the gradient of the loss function and through an optimization algorithm, and the iterative training operation is repeated on the trained model.

[0091] When it is determined that the trained model tends to converge, the iterative training operation is stopped, and the final target model is obtained.

[0092] As an optional implementation, in the second aspect of the present invention, the optimization algorithm includes one of: gradient descent, stochastic gradient descent, mini-batch gradient descent, Adam, RMSProp, momentum, and AdaGrad;

[0093] The preset cost estimation algorithm is expressed as follows:

[0094] .

[0095] As an optional implementation, in the second aspect of the present invention, the enterprise production efficiency parameter includes at least one of the following: reuse coefficient, complexity coefficient, industry coefficient, and cost coefficient;

[0096] The calculation module inputs the dataset corresponding to the function points of the software under test into the target model for calculation, and obtains the function point size estimation parameters and enterprise production efficiency parameters in the following specific way:

[0097] The dataset corresponding to the function points of the software under test is input into the target model for calculation to obtain the function point size estimation parameters and historical project feature parameters.

[0098] Enterprise production efficiency parameters are generated based on the function point size estimation parameters and historical project characteristic parameters.

[0099] A third aspect of this invention discloses another software function point evaluation system based on a large model, the system comprising:

[0100] Memory containing executable program code;

[0101] A processor coupled to the memory;

[0102] The processor calls the executable program code stored in the memory to execute the software function point evaluation method based on a large model disclosed in the first aspect of the present invention.

[0103] The fourth aspect of the present invention discloses a computer storage medium storing computer instructions, which, when invoked, are used to execute the software function point evaluation method based on a large model disclosed in the first aspect of the present invention.

[0104] Compared with the prior art, the embodiments of the present invention have the following beneficial effects:

[0105] This invention provides a software function point evaluation method and system based on a large model. The method includes: preprocessing text data from a pre-defined enterprise R&D efficiency training library to obtain a preprocessed corpus. The corpus includes at least a labeled dataset corresponding to software function points with labeled evaluation parameters, which improves the efficiency and accuracy of subsequent pre-model training; initializing the model parameters of the pre-trained model and inputting the labeled dataset from the corpus into the pre-trained model for iterative training to obtain a trained target model, which improves the accuracy of software cost evaluation; inputting the test dataset corresponding to the function points of the software under test into the target model for calculation to obtain function point size estimation parameters and enterprise production efficiency parameters; and calculating the estimated cost of the software under test based on the function point size estimation parameters, enterprise production efficiency parameters, and a pre-defined cost estimation algorithm. Therefore, implementing this invention can unify the process and quantitative standards for enterprise software cost estimation, improve the applicability of software cost estimation schemes, realize the intelligent and automated calculation of software costs, reduce the time spent on manual document review and the time required for the cost estimation process, thereby improving the efficiency and accuracy of software cost evaluation. Attached Figure Description

[0106] To more clearly illustrate the technical solutions in the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0107] Figure 1 This is a flowchart illustrating a software function point evaluation method based on a large model disclosed in an embodiment of the present invention;

[0108] Figure 2 This is a flowchart illustrating another software function point evaluation method based on a large model disclosed in an embodiment of the present invention.

[0109] Figure 3 This is a schematic diagram of the structure of a software function point evaluation system based on a large model disclosed in an embodiment of the present invention;

[0110] Figure 4 This is a schematic diagram of another software function point evaluation system based on a large model disclosed in an embodiment of the present invention;

[0111] Figure 5 This is a schematic diagram of the structure of another software function point evaluation system based on a large model disclosed in an embodiment of the present invention. Detailed Implementation

[0112] To enable those skilled in the art to better understand the present invention, the technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings of the embodiments of the present invention. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0113] The terms "first," "second," etc., used in the specification, claims, and accompanying drawings of this invention are used to distinguish different objects, not to describe a specific order. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion. For example, a process, method, system, product, or end that includes a series of steps or units is not limited to the listed steps or units, but may optionally include steps or units not listed, or may optionally include other steps or units inherent to these processes, methods, products, or ends.

[0114] In this document, the term "embodiment" means that a particular feature, structure, or characteristic described in connection with an embodiment may be included in at least one embodiment of the invention. The appearance of this phrase in various places throughout the specification does not necessarily refer to the same embodiment, nor is it a separate or alternative embodiment mutually exclusive with other embodiments. It will be explicitly and implicitly understood by those skilled in the art that the embodiments described herein can be combined with other embodiments.

[0115] This invention discloses a software function point evaluation method and system based on a large model. It preprocesses text data from a pre-defined enterprise R&D efficiency training library to obtain a preprocessed corpus. The corpus includes at least labeled datasets corresponding to software function points with annotated evaluation parameters, which improves the efficiency and accuracy of subsequent pre-model training. The system initializes the model parameters of the pre-trained model and inputs the labeled datasets from the corpus into the pre-trained model for iterative training, obtaining a trained target model. The system then inputs the datasets corresponding to the function points of the software under test into the target model for calculation, obtaining function point size estimation parameters and enterprise production efficiency parameters. Finally, based on the function point size estimation parameters, enterprise production efficiency parameters, and a pre-defined cost estimation algorithm, the estimated cost of the software under test is calculated. This method unifies the process and quantification standards for enterprise software cost estimation, improves the applicability of software cost estimation schemes, and achieves intelligent and automated software cost calculation. It reduces the time spent on manual document review and the time required for the cost estimation process, thereby improving the efficiency and accuracy of software cost evaluation. Detailed explanations follow.

[0116] Example 1

[0117] Please see Figure 1 , Figure 1 This is a flowchart illustrating a software function point evaluation method based on a large model, as disclosed in an embodiment of the present invention. Wherein, Figure 1 The described large-model-based software function point evaluation method can be applied to large-model-based software function point evaluation systems, as well as large-model-based software cost estimation systems; this embodiment of the invention is not limited thereto. Optionally, the system can be applied to local terminal devices (e.g., PC terminals, local servers, etc.) or mobile terminal devices (e.g., smartphones, tablets, PDAs, mobile internet devices, etc.); this embodiment of the invention is not limited thereto. Figure 1 As shown, this large-model-based software function point evaluation method may include the following operations:

[0118] 101. Perform preprocessing operations on the text data in the preset enterprise R&D efficiency training library to obtain the preprocessed corpus.

[0119] In this embodiment of the invention, optionally, the enterprise R&D efficiency training library may include at least one of the following: enterprise human resource data, enterprise revenue and expenditure data, historical project requirement data, historical project technical route data, and historical project development architecture data. The corpus may at least include annotated datasets corresponding to software function points with labeled evaluation parameters. The annotated datasets may include multiple texts and / or words and / or phrases used to describe the software function points. Preprocessing operations may include at least one of the following: data cleaning, data filtering, data transformation, and data normalization. Data transformation operations may include semantic transformation and / or translation, grammatical transformation and / or simplification of text data. For example, for the same software function point (user login function), the text description in the software manual of software A is that the system supports user login, while the text description in the software manual of software B is that the system supports user registration and login using a registered account, and provides prompts for login errors. This is essentially an equivalent function, therefore it needs to be converted into a standard text description through data transformation operations. This embodiment of the invention does not limit this. This provides a unified reference standard, which is beneficial for improving the accuracy of text references, thereby improving the efficiency and accuracy of software cost assessment.

[0120] 102. Initialize the model parameters of the pre-trained model, and input the labeled dataset from the corpus into the pre-trained model for iterative training to obtain the trained target model.

[0121] In this embodiment of the invention, optionally, the pre-trained model is represented as a sequence-to-sequence neural network model (Transformer model) based on a self-attention mechanism, and the model parameters of the pre-trained model may include at least a self-attention layer, a multi-head attention layer, a feedforward neural network layer, etc.

[0122] The attention layer can include: input sequence, query, key, value, attention weights, and output layer. The input sequence of the attention layer is represented as follows: The parameter of the input sequence is coppus, where i represents the i-th element of the input sequence.

[0123] The formula for calculating the linear transformation of query, key, and value is:

[0124]

[0125] The formula for calculating attention weights is:

[0126]

[0127] The formula for calculating the output layer is:

[0128]

[0129] Where Q represents the query, K represents the key, and V represents the value. Represented as a query weight matrix, Represented as a key weight matrix, Represented as a value weight matrix, Let be the transpose of the key matrix, attention be the attention weights, softmax be the normalized exponent function, d be the dimension, and output be the output parameters.

[0130] In an embodiment of the present invention, the multi-head attention layer may optionally include: an input sequence, a head, attention weights of the heads, and an output layer.

[0131] The formula for calculating the attention weight for each head is:

[0132]

[0133] The formula for calculating the output layer is:

[0134]

[0135] in, Let represent the i-th head of the multi-head attention layer, h represent the number of heads, selfAttention represent the self-attention mechanism function, WO represent the linear transformation corresponding to the output layer of the self-attention layer, multihead_attention represent the output parameters of the multi-head attention layer, and concat represent the function used to connect two or more arrays.

[0136] In this embodiment of the invention, optionally, the feedforward neural network layer may include at least: an input layer, a hidden layer, and an output layer, wherein the parameters input to the input layer of the feedforward neural network layer are the output parameters of the multi-head attention.

[0137] The formula for calculating the hidden layer is expressed as follows:

[0138] The calculation formula for the output layer is expressed as follows:

[0139] in, This is represented as the weight value of the hidden layer. This is represented as the bias value of the hidden layer. This is represented as the weight value of the output layer. This is represented as the bias value of the output layer.

[0140] By initializing the model parameters of the pre-trained Transformer model and inputting the labeled dataset from the corpus into the pre-trained model for iterative training, the trained target model is obtained. This fully utilizes the advantages of the Transformer model's high computational efficiency and strong scalability, thereby improving the efficiency and accuracy of software cost assessment.

[0141] In this embodiment of the invention, inputting the labeled dataset from the corpus into the pre-trained model for iterative training to obtain the trained target model may include:

[0142] The labeled dataset from the corpus is input into the pre-trained model for iterative training to obtain the trained model.

[0143] The loss function of the pre-trained model is used to determine whether the trained model tends to converge.

[0144] When it is determined that the trained model has not converged, the model parameters are updated according to the gradient of the loss function and through the optimization algorithm, and the iterative training operation is repeated on the trained model.

[0145] When it is determined that the trained model is converging, the iterative training operation is stopped, and the final target model is obtained.

[0146] The optimization algorithm may include one of the following: gradient descent, stochastic gradient descent, mini-batch gradient descent, Adam, RMSProp, momentum, AdaGrad, etc., and the embodiments of the present invention are not limited thereto.

[0147] This approach uses the loss function of the pre-trained model to determine whether the trained model is converging. If it is determined that the trained model is not converging, the model parameters are updated using the gradient of the loss function and an optimization algorithm, and the trained model is iteratively trained again. When it is determined that the trained model is converging, the iterative training is stopped to obtain the final target model. This prevents the trained model from overfitting and allows the use of optimization algorithms to update the model parameters, which helps to accelerate the training of the target model and thus improves the efficiency and accuracy of subsequent software cost assessment.

[0148] 103. Input the dataset corresponding to the function points of the software under test into the target model for calculation to obtain the function point size estimation parameters and enterprise production efficiency parameters. Based on the function point size estimation parameters, enterprise production efficiency parameters, enterprise cost parameters and the preset cost estimation algorithm, calculate the estimated cost of the software under test.

[0149] In this embodiment of the invention, the enterprise production efficiency parameter may optionally include at least one of the following: reuse coefficient, complexity coefficient, industry coefficient, cost coefficient, etc., and this embodiment of the invention does not limit it.

[0150] The preset cost estimation algorithm is expressed as follows:

[0151]

[0152] In this embodiment of the invention, the dataset corresponding to the function points of the software under test is input into the target model for calculation to obtain function point size estimation parameters and enterprise production efficiency parameters, which may include:

[0153] The dataset corresponding to the function points of the software under test is input into the target model for calculation, and the function point size estimation parameters and historical project feature parameters are obtained.

[0154] The historical project feature parameters can be understood as a high-dimensional projection of historical projects, or vectorization, or target feature values ​​calculated using the MD5 algorithm. These parameters can be used to quickly identify whether similar projects have been undertaken before a new project.

[0155] This method, by calculating the estimated cost of the software under test using the function point scale estimation parameters, enterprise production efficiency parameters, and enterprise cost parameters obtained from the target model, along with the preset cost estimation algorithm, can unify the process and quantitative standards for enterprise software cost estimation, improve the applicability of software cost estimation schemes, and thus help improve the efficiency and accuracy of software cost assessment.

[0156] Enterprise production efficiency parameters are generated based on function point size estimation parameters and historical project characteristic parameters.

[0157] In an optional embodiment, before performing step 102, the method further includes the following operations:

[0158] The loss function of the pre-trained model is constructed based on the text and / or words and / or phrases in the corpus.

[0159] In this optional embodiment, the loss function can be calculated as follows:

[0160]

[0161]

[0162] Here, coppus refers to a library of texts and / or words and / or phrases used to describe software function points. Represented as a loss function, This represents the nth character, word, or phrase in the corpus. This represents the number of tokens in the corpus. denoted as GPT model parameters, the GPT model (Generative Pre-trained Transformer) is a generative pre-trained language model developed by OpenAI based on the Transformer architecture. It can understand and generate natural language text through unsupervised pre-training and supervised fine-tuning. p represents the probability function, which is used to calculate the probability of predicting the nth character, word, or phrase given the context of the first K words.

[0163] As can be seen, this optional embodiment can construct the loss function of the pre-trained model based on the text and / or words and / or phrases in the corpus, reducing the error of the training model and thus preventing overfitting of the training model, which is beneficial to improving the efficiency and accuracy of software cost assessment.

[0164] In an optional embodiment, after performing step 102 to initialize the model parameters of the pre-trained model, the method further includes the following operations:

[0165] Freeze some model parameters of the pre-trained model according to preset freeze parameters. For example, you can freeze some invalid or unused weights in the hidden layers of the pre-trained model based on specific types of data in the test dataset.

[0166] As can be seen, this optional embodiment can freeze some model parameters of the pre-trained model according to preset freezing parameters, thereby improving the computational efficiency and accuracy of the model, preventing the training model from overfitting, and thus helping to improve the efficiency and accuracy of software cost assessment.

[0167] Example 2

[0168] Please see Figure 2 , Figure 2 This is a flowchart illustrating a software function point evaluation method based on a large model, as disclosed in an embodiment of the present invention. Wherein, Figure 2 The described large-model-based software function point evaluation method can be applied to large-model-based software function point evaluation systems, as well as large-model-based software cost estimation systems; this embodiment of the invention is not limited thereto. Optionally, the system can be applied to local terminal devices (e.g., PC terminals, local servers, etc.) or mobile terminal devices (e.g., smartphones, tablets, PDAs, mobile internet devices, etc.); this embodiment of the invention is not limited thereto. Figure 2 As shown, this large-model-based software function point evaluation method may include the following operations:

[0169] 201. Perform preprocessing operations on the text data in the preset enterprise R&D efficiency training library to obtain the preprocessed corpus.

[0170] 202. Based on the semantic type that matches the text data corresponding to each software function point in the corpus, perform semantic type annotation on the text data corresponding to each software function point.

[0171] 203. Based on the syntax type that matches the text data corresponding to each software function point in the corpus, perform syntax type annotation on the text data corresponding to each software function point.

[0172] 204. Based on the preset evaluation parameters, determine the evaluation parameters that match the text data corresponding to each software function point, and obtain the labeled dataset corresponding to the software function points with labeled evaluation parameters.

[0173] In this embodiment of the invention, the evaluation parameters may optionally include at least one of the following: development benefit level, development cost level, development scale level, complexity level, etc., which are matched with the text data corresponding to each software function point. This embodiment of the invention does not limit the parameters.

[0174] In this embodiment of the invention, optionally, evaluation parameters matching each code segment corresponding to each software function point can be determined according to preset code evaluation parameters, thereby obtaining an annotated dataset corresponding to the software function points with annotated evaluation parameters. The code evaluation parameters may include at least one of the following: readability, maintainability, time complexity, reusability, security, and consistency of the code segment; this embodiment of the invention does not impose any limitations on these parameters.

[0175] 205. Initialize the model parameters of the pre-trained model, and input the labeled dataset from the corpus into the pre-trained model for iterative training to obtain the trained target model.

[0176] 206. Input the dataset corresponding to the function points of the software under test into the target model for calculation to obtain the function point size estimation parameters and enterprise production efficiency parameters. Calculate the estimated cost of the software under test based on the function point size estimation parameters, enterprise production efficiency parameters, enterprise cost parameters, and the preset cost estimation algorithm.

[0177] In this embodiment of the invention, for other descriptions of steps 201 and 205-206, please refer to the detailed description of steps 101-104 in Embodiment 1. This embodiment of the invention will not repeat them.

[0178] As can be seen, implementing the embodiments of the present invention can annotate the text data corresponding to each software function point with semantic and / or grammatical types according to the semantic and / or grammatical types that match the text data corresponding to each software function point in the corpus, and determine the evaluation parameters that match the text data corresponding to each software function point according to preset evaluation parameters, thereby obtaining the labeled dataset corresponding to the software function points with labeled evaluation parameters. This is beneficial to improving the accuracy and diversity of the model training set, improving the training efficiency of the model, thereby improving the generalization ability of the model, and improving the efficiency and accuracy of software cost evaluation.

[0179] It is evident that implementation Figure 2 The described large-model-based software function point evaluation method preprocesses text data from a pre-defined enterprise R&D efficiency training corpus to obtain a preprocessed corpus. This corpus includes at least labeled datasets corresponding to the software function points with annotated evaluation parameters, which improves the efficiency and accuracy of subsequent pre-model training. The method initializes the model parameters of the pre-trained model and inputs the labeled datasets from the corpus into iterative training to obtain the trained target model. The target model then calculates the dataset corresponding to the function points of the software under test, yielding function point size estimation parameters and enterprise production efficiency parameters. Finally, based on the function point size estimation parameters, enterprise production efficiency parameters, and a pre-defined cost estimation algorithm, the final cost estimate is calculated. The estimated cost of software testing can standardize the process and quantification standards for enterprise software cost estimation, improving the applicability of software cost estimation schemes. Furthermore, by annotating the text data corresponding to each software function point in the corpus with semantic and / or grammatical types, and by determining the corresponding evaluation parameters based on preset evaluation parameters, a labeled dataset for each software function point with annotated evaluation parameters is obtained. This helps improve the accuracy and diversity of the model training set, increases model training efficiency, and thus improves the model's generalization ability, as well as the efficiency and accuracy of software cost estimation.

[0180] Example 3

[0181] Please see Figure 3 , Figure 3 This is a schematic diagram of the structure of a software function point evaluation system based on a large model, as disclosed in an embodiment of the present invention. Figure 3 The described large-model-based software function point evaluation system can execute the aforementioned large-model-based software function point evaluation method. This method can also be applied to large-model-based software cost estimation systems; this embodiment of the invention is not limited thereto. Optionally, the system can be applied to local terminal devices (e.g., PC terminals, local servers, etc.) or mobile terminal devices (e.g., smartphones, tablets, PDAs, mobile internet devices, etc.); this embodiment of the invention is not limited thereto. Figure 3 As shown, the software function point evaluation system based on a large model may include a preprocessing module 301, an initialization module 302, a training module 303, and a calculation module 304, wherein:

[0182] The preprocessing module 301 is used to preprocess the text data in the preset enterprise R&D efficiency training library to obtain a preprocessed corpus. The corpus includes at least the labeled dataset corresponding to the software function points with labeled evaluation parameters.

[0183] Initialization module 302 is used to initialize the model parameters of the pre-trained model.

[0184] The training module 303 is used to input the labeled dataset from the corpus processed by the preprocessing module 301 into the pre-trained model initialized by the initialization module 302 for iterative training to obtain the trained target model.

[0185] The calculation module 304 is used to input the test dataset corresponding to the function points of the software under test into the target model trained by the training module 303 for calculation, and obtain the function point size estimation parameters and enterprise production efficiency parameters. Furthermore, based on the function point size estimation parameters, enterprise production efficiency parameters, enterprise cost parameters, and a preset cost estimation algorithm, the estimated cost of the software under test is calculated.

[0186] It is evident that implementation Figure 3The described large-model-based software function point evaluation system can preprocess text data in a pre-defined enterprise R&D efficiency training library to obtain a preprocessed corpus. This corpus includes at least labeled datasets corresponding to the software function points with annotated evaluation parameters, which improves the efficiency and accuracy of subsequent pre-model training. The system initializes the model parameters of the pre-trained model and inputs the labeled datasets from the corpus into the pre-trained model for iterative training, resulting in a trained target model. The system then inputs the datasets corresponding to the function points of the software under test into the target model for calculation, obtaining function point size estimation parameters and enterprise production efficiency parameters. Finally, based on the function point size estimation parameters, enterprise production efficiency parameters, and a pre-defined cost estimation algorithm, the system calculates the estimated cost of the software under test. This system standardizes the process and quantification standards for enterprise software cost estimation, improves the applicability of software cost estimation schemes, and achieves intelligent and automated software cost calculation. It reduces the time spent on manual document review and the time required for the cost estimation process, thereby improving the efficiency and accuracy of software cost evaluation.

[0187] In an optional embodiment, the enterprise R&D efficiency training library includes at least one of the following: enterprise human resources data, enterprise revenue and expenditure data, historical project requirement data, historical project technical route data, and historical project development architecture data. The labeled dataset includes multiple texts and / or words and / or phrases used to describe software functional points. The preprocessing operations include at least one of the following: data cleaning, data filtering, data transformation, and data normalization.

[0188] And such as Figure 4 As shown, the system also includes:

[0189] The construction module 305 is used to construct the loss function of the pre-trained model based on the text and / or words and / or phrases in the corpus before the initialization module 302 initializes the model parameters of the pre-trained model.

[0190] The formula for calculating the loss function is as follows:

[0191]

[0192]

[0193] Here, coppus refers to a library of texts and / or words and / or phrases used to describe software function points. Let p represent the loss function, and p represent the probability function. This represents the nth character, word, or phrase in the corpus. This represents the number of tokens in the corpus. These are represented as GPT model parameters.

[0194] And, the freeze module 306 is used to freeze some of the model parameters of the pre-trained model according to the preset freeze parameters after the initialization module 302 initializes the model parameters of the pre-trained model.

[0195] It is evident that implementation Figure 4 The described large-model-based software function point evaluation system can construct the loss function of the pre-trained model based on the text and / or words and / or short sentences in the corpus, reducing the error of the training model and thus preventing overfitting; and can freeze some model parameters of the pre-trained model according to preset freezing parameters, thereby improving the computational efficiency and accuracy of the model and preventing overfitting, which is conducive to improving the efficiency and accuracy of software cost evaluation.

[0196] In another alternative embodiment, such as Figure 4 As shown, the system also includes:

[0197] The annotation module 307 is used to perform preprocessing operations on the text data in the preset enterprise R&D efficiency training library in the preprocessing module 301 to obtain the preprocessed corpus. Then, it performs semantic type annotation on the text data corresponding to each software function point according to the semantic type that matches the text data corresponding to each software function point in the corpus; and / or, it performs grammatical type annotation on the text data corresponding to each software function point according to the grammatical type that matches the text data corresponding to each software function point in the corpus; and, according to the preset evaluation parameters, it determines the evaluation parameters that match the text data corresponding to each software function point to obtain the annotated dataset corresponding to the software function points with the annotated evaluation parameters.

[0198] The evaluation parameters include at least one of the following: development benefit level, development cost level, development scale level, and complexity level, which are matched with the text data corresponding to each software function point.

[0199] It is evident that implementation Figure 4 The described large-model-based software feature point evaluation system can annotate the text data corresponding to each software feature point in the corpus with semantic and / or syntactic types based on the semantic and / or syntactic types that match the text data corresponding to each software feature point. Furthermore, it determines the evaluation parameters that match the text data corresponding to each software feature point based on preset evaluation parameters, resulting in an annotated dataset for the software feature points with annotated evaluation parameters. This improves the accuracy and diversity of the model training set, increases the model's training efficiency, and consequently enhances the model's generalization ability, as well as the efficiency and accuracy of software cost evaluation.

[0200] In another optional embodiment, the pre-trained model is represented as a sequence-to-sequence neural network model based on a self-attention mechanism, and the model parameters of the pre-trained model include at least a self-attention layer, a multi-head attention layer, and a feedforward neural network layer.

[0201] The self-attention layer comprises: an input sequence, a query, a key, a value, attention weights, and an output layer. The input sequence of the self-attention layer is represented as follows: The parameter of the input sequence is coppus, where i represents the i-th element of the input sequence.

[0202] The formula for calculating the linear transformation of query, key, and value is:

[0203]

[0204] The formula for calculating attention weights is:

[0205]

[0206] The formula for calculating the output layer is:

[0207]

[0208] Where Q represents the query, K represents the key, and V represents the value. Represented as a query weight matrix, Represented as a key weight matrix, It is represented as a value weight matrix, attention represents attention weights, d represents the dimension, and output represents the output parameters.

[0209] A multi-head attention layer consists of: an input sequence, a head, attention weights for each head, and an output layer.

[0210] The formula for calculating the attention weight for each head is:

[0211]

[0212] The formula for calculating the output layer is:

[0213]

[0214] in, Let represent the i-th head of the multi-head attention layer, h represent the number of heads, selfAttention represent the self-attention mechanism function, WO represent the linear transformation corresponding to the output layer of the self-attention layer, and multihead_attention represent the output parameters of the multi-head attention layer.

[0215] A feedforward neural network layer includes at least: an input layer, a hidden layer, and an output layer.

[0216] It is evident that implementation Figure 4 The software function point evaluation system based on the large model described herein can fully utilize the advantages of the Transformer model in terms of high computational efficiency and strong scalability, thereby improving the efficiency and accuracy of software cost evaluation.

[0217] In yet another alternative embodiment, such as Figure 4 As shown, the training module 303 inputs the labeled dataset from the corpus into the pre-trained model for iterative training to obtain the trained target model in the following specific way:

[0218] The labeled dataset from the corpus is input into the pre-trained model for iterative training to obtain the trained model.

[0219] The loss function of the pre-trained model is used to determine whether the trained model tends to converge.

[0220] When it is determined that the trained model has not converged, the model parameters are updated according to the gradient of the loss function and through the optimization algorithm, and the iterative training operation is repeated on the trained model.

[0221] When it is determined that the trained model is converging, the iterative training operation is stopped, and the final target model is obtained.

[0222] It is evident that implementation Figure 4 The described large-model-based software function point evaluation system can determine whether the trained model is converging based on the loss function of the pre-trained model. When it is determined that the trained model has not converged, the system updates the model parameters based on the gradient of the loss function and through an optimization algorithm, and repeats the iterative training of the trained model. When it is determined that the trained model is converging, the iterative training operation is stopped to obtain the final target model. This system can prevent the trained model from overfitting and can use optimization algorithms to update the model parameters, which helps to accelerate the training of the target model and thus improve the efficiency and accuracy of subsequent software cost evaluation.

[0223] In yet another alternative embodiment, the optimization algorithm includes one of gradient descent, stochastic gradient descent, mini-batch gradient descent, Adam, RMSProp, momentum, and AdaGrad.

[0224] The preset cost estimation algorithm is expressed as follows:

[0225] .

[0226] It is evident that implementation Figure 4The software function point evaluation system based on a large model described herein can calculate the estimated cost of the software under test based on the function point scale estimation parameters, enterprise production efficiency parameters, enterprise cost parameters, and preset cost estimation algorithms obtained from the target model. This system can unify the process and quantitative standards for enterprise software cost estimation, improve the applicability of software cost estimation schemes, and thus help improve the efficiency and accuracy of software cost evaluation.

[0227] In another optional embodiment, the enterprise production efficiency parameter includes at least one of the following: reuse coefficient, complexity coefficient, industry coefficient, and cost coefficient.

[0228] And such as Figure 4 As shown, the calculation module 304 inputs the dataset corresponding to the function points of the software under test into the target model for calculation, and obtains the function point size estimation parameters and enterprise production efficiency parameters in the following specific way:

[0229] The dataset corresponding to the function points of the software under test is input into the target model for calculation, and the function point size estimation parameters and historical project feature parameters are obtained.

[0230] Enterprise production efficiency parameters are generated based on function point size estimation parameters and historical project characteristic parameters.

[0231] It is evident that implementation Figure 4 The software function point evaluation system based on a large model described herein can calculate the estimated cost of the software under test based on the function point scale estimation parameters, enterprise production efficiency parameters, enterprise cost parameters, and preset cost estimation algorithms obtained from the target model. This system can unify the process and quantitative standards for enterprise software cost estimation, improve the applicability of software cost estimation schemes, and thus help improve the efficiency and accuracy of software cost evaluation.

[0232] Example 4

[0233] Please see Figure 5 , Figure 5 This is a schematic diagram of the structure of another software function point evaluation system based on a large model disclosed in an embodiment of the present invention. Figure 5 As shown, this large-model-based software function point evaluation system may include:

[0234] Memory 401 storing executable program code;

[0235] Processor 402 coupled to memory 401;

[0236] The processor 402 calls the executable program code stored in the memory 401 to execute the steps in the software function point evaluation method based on a large model as described in Embodiment 1 or Embodiment 2 of the present invention.

[0237] Example 5

[0238] This invention discloses a computer storage medium storing computer instructions. When these computer instructions are invoked, they are used to execute the steps in the software function point evaluation method based on a large model as described in Embodiment 1 or Embodiment 2 of this invention.

[0239] Example 6

[0240] This invention discloses a computer program product, which includes a non-transitory computer-readable storage medium storing a computer program, and the computer program is operable to cause a computer to perform the steps in the software function point evaluation method based on a large model described in Embodiment 1 or Embodiment 2.

[0241] The system embodiments described above are merely illustrative. The modules described as separate components may or may not be physically separate. The components shown as modules may or may not be physical modules; that is, they may be located in one place or distributed across multiple network modules. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs. Those skilled in the art can understand and implement this without any creative effort.

[0242] Through the detailed description of the above embodiments, those skilled in the art can clearly understand that each implementation method can be implemented by means of software plus necessary general-purpose hardware platforms, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solutions, in essence or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, including read-only memory (ROM), random access memory (RAM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), one-time programmable read-only memory (OTPROM), electrically-Erasable Programmable Read-Only Memory (EEPROM), compact disc read-only memory (CD-ROM) or other optical disc storage, disk storage, magnetic tape storage, or any other computer-readable medium that can be used to carry or store data.

[0243] Finally, it should be noted that the software function point evaluation method and system based on a large model disclosed in the embodiments of the present invention are merely preferred embodiments of the present invention, and are only used to illustrate the technical solutions of the present invention, not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A software function point evaluation method based on a large model, characterized in that, The method includes: The text data in the preset enterprise R&D efficiency training library is preprocessed to obtain a preprocessed corpus. The corpus includes at least a labeled dataset corresponding to the software function points with labeled evaluation parameters. The model parameters of the pre-trained model are initialized, and the labeled dataset in the corpus is input into the pre-trained model for iterative training to obtain the trained target model; The dataset corresponding to the function points of the software under test is input into the target model for calculation to obtain the function point size estimation parameters and enterprise production efficiency parameters. The estimated cost of the software under test is calculated based on the functional point scale estimation parameters, the enterprise production efficiency parameters, the enterprise cost parameters, and the preset cost estimation algorithm. The enterprise R&D efficiency training library includes at least one of the following: enterprise human resources data, enterprise revenue and expenditure data, historical project requirement data, historical project technical route data, and historical project development architecture data. The labeled dataset includes multiple texts and / or words and / or short sentences used to describe the software function points. The preprocessing operations include at least one of the following: data cleaning, data filtering, data transformation, and data normalization. Before initializing the model parameters of the pre-trained model, the method further includes: The loss function of the pre-trained model is constructed based on the text and / or words and / or phrases in the corpus. The formula for calculating the loss function is as follows: Wherein, "coppus" refers to the corpus comprising multiple texts and / or words and / or phrases used to describe the software functionalities. Let p represent the loss function, and let p represent the probability function. This refers to the nth character, word, or phrase in the corpus, where N represents the number of tokens in the corpus. K is represented as the GPT model parameter, where K represents the number of given words used to predict the probability of the nth character, word, or phrase. Furthermore, after initializing the model parameters of the pre-trained model, the method further includes: Freeze some model parameters of the pre-trained model according to preset freeze parameters; After preprocessing the text data in the preset enterprise R&D efficiency training library to obtain the preprocessed corpus, the method further includes: Based on the semantic type matching the text data corresponding to each software function point in the corpus, semantic type annotation is performed on the text data corresponding to each software function point; and / or, Based on the syntax type that matches the text data corresponding to each software function point in the corpus, the text data corresponding to each software function point is annotated with syntax type. Furthermore, based on preset evaluation parameters, evaluation parameters that match the text data corresponding to each software function point are determined, thereby obtaining an annotated dataset corresponding to the software function points annotated with the evaluation parameters. The evaluation parameters include at least one of the following: development benefit level, development cost level, development scale level, and complexity level, which are matched with the text data corresponding to each software function point.

2. The software function point evaluation method based on a large model according to claim 1, characterized in that, The pre-trained model is represented as a sequence-to-sequence neural network model based on a self-attention mechanism, and the model parameters of the pre-trained model include at least a self-attention layer, a multi-head attention layer, and a feedforward neural network layer. The self-attention layer comprises: an input sequence, a query, a key, a value, attention weights, and an output layer. The input sequence of the self-attention layer is represented as follows: The parameter of the input sequence is the coppus, and i represents the i-th element of the input sequence; The linear transformation calculation formula for the query, the key, and the value is as follows: The formula for calculating the attention weight is: The calculation formula for the output layer is: Wherein, Q represents the query, K represents the key, and V represents the value. Represented as a query weight matrix, the Represented as a key weight matrix, the It is represented as a value weight matrix, where attention represents the attention weights, d represents the dimension, and output represents the output parameters; The multi-head attention layer includes: the input sequence, the head, the attention weights of the head, and the output layer; The formula for calculating the attention weight for each head is: The calculation formula for the output layer is: Among them, the Let represent the i-th head of the multi-head attention, h represent the number of heads, selfAttention represent the self-attention mechanism function, WO represent the linear transformation corresponding to the output layer of the self-attention layer, and multihead_attention represent the output parameters of the multi-head attention layer; The feedforward neural network layer includes at least: an input layer, a hidden layer, and an output layer.

3. The software function point evaluation method based on a large model according to claim 1, characterized in that, The step of inputting the labeled dataset from the corpus into the pre-trained model for iterative training to obtain the trained target model includes: The labeled dataset from the corpus is input into the pre-trained model for iterative training to obtain the trained model. Determine whether the trained model tends to converge based on the loss function of the pre-trained model; When it is determined that the trained model has not converged, the model parameters are updated according to the gradient of the loss function and through an optimization algorithm, and the iterative training operation is repeated on the trained model. When it is determined that the trained model tends to converge, the iterative training operation is stopped, and the final target model is obtained.

4. The software function point evaluation method based on a large model according to claim 3, characterized in that, The optimization algorithm includes one of the following: gradient descent, stochastic gradient descent, mini-batch gradient descent, Adam, RMSProp, momentum, and AdaGrad. The calculation formula for the cost estimation algorithm is expressed as follows: 。 5. The software function point evaluation method based on a large model according to claim 3, characterized in that, The enterprise production efficiency parameters include at least one of the following: reuse coefficient, complexity coefficient, industry coefficient, and cost coefficient; The step of inputting the dataset corresponding to the function points of the software under test into the target model for calculation to obtain function point size estimation parameters and enterprise production efficiency parameters includes: The dataset corresponding to the function points of the software under test is input into the target model for calculation to obtain the function point size estimation parameters and historical project feature parameters. Enterprise production efficiency parameters are generated based on the function point size estimation parameters and historical project characteristic parameters.

6. A software function point evaluation system based on a large model, characterized in that, The system includes: The preprocessing module is used to preprocess the text data in the preset enterprise R&D efficiency training library to obtain a preprocessed corpus. The corpus includes at least the labeled dataset corresponding to the software function points with labeled evaluation parameters. The initialization module is used to initialize the model parameters of the pre-trained model; The training module is used to input the labeled dataset from the corpus obtained by the preprocessing module into the pre-trained model initialized by the initialization module for iterative training to obtain the trained target model. The calculation module is used to input the dataset corresponding to the function points of the software under test into the target model trained by the training module for calculation, to obtain function point size estimation parameters and enterprise production efficiency parameters; and to calculate the estimated cost of the software under test based on the function point size estimation parameters, the enterprise production efficiency parameters, the enterprise cost parameters and the preset cost estimation algorithm. The enterprise R&D efficiency training library includes at least one of the following: enterprise human resources data, enterprise revenue and expenditure data, historical project requirement data, historical project technical route data, and historical project development architecture data. The labeled dataset includes multiple texts and / or words and / or short sentences used to describe the software function points. The preprocessing operations include at least one of the following: data cleaning, data filtering, data transformation, and data normalization. The system also includes: A construction module is used to construct the loss function of the pre-trained model based on the text and / or words and / or phrases in the corpus before the initialization module initializes the model parameters of the pre-trained model. The formula for calculating the loss function is as follows: Wherein, "coppus" refers to the corpus comprising multiple texts and / or words and / or phrases used to describe the software functionalities. Let p represent the loss function, and let p represent the probability function. This refers to the nth character, word, or phrase in the corpus, where N represents the number of tokens in the corpus. K is represented as the GPT model parameter, where K represents the number of given words used to predict the probability of the nth character, word, or phrase. And, a freeze module, used to freeze some of the model parameters of the pre-trained model according to preset freeze parameters after the initialization module initializes the model parameters of the pre-trained model; The system also includes: The annotation module is used to perform preprocessing operations on the text data in the preset enterprise R&D efficiency training library in the preprocessing module to obtain a preprocessed corpus, and then to perform semantic type annotation on the text data corresponding to each software function point according to the semantic type that matches the text data corresponding to each software function point in the corpus; and / or, to perform grammatical type annotation on the text data corresponding to each software function point according to the grammatical type that matches the text data corresponding to each software function point; and to determine the evaluation parameters that match the text data corresponding to each software function point according to preset evaluation parameters, so as to obtain the annotated dataset corresponding to the software function points annotated with the evaluation parameters. The evaluation parameters include at least one of the following: development benefit level, development cost level, development scale level, and complexity level, which are matched with the text data corresponding to each software function point.

7. A software function point evaluation system based on a large model, characterized in that, The system includes: Memory containing executable program code; A processor coupled to the memory; The processor calls the executable program code stored in the memory to execute the software function point evaluation method based on a large model as described in any one of claims 1-5.

8. A computer storage medium, characterized in that, The computer storage medium stores computer instructions, which, when invoked, are used to execute the software function point evaluation method based on a large model as described in any one of claims 1-5.

Images