diff --git "a/title_30K/test_title_long_2404.16745v1.json" "b/title_30K/test_title_long_2404.16745v1.json"
new file mode 100644--- /dev/null
+++ "b/title_30K/test_title_long_2404.16745v1.json"
@@ -0,0 +1,103 @@
+{
+    "url": "http://arxiv.org/abs/2404.16745v1",
+    "title": "Statistical Inference for Covariate-Adjusted and Interpretable Generalized Factor Model with Application to Testing Fairness",
+    "abstract": "In the era of data explosion, statisticians have been developing\ninterpretable and computationally efficient statistical methods to measure\nlatent factors (e.g., skills, abilities, and personalities) using large-scale\nassessment data. In addition to understanding the latent information, the\ncovariate effect on responses controlling for latent factors is also of great\nscientific interest and has wide applications, such as evaluating the fairness\nof educational testing, where the covariate effect reflects whether a test\nquestion is biased toward certain individual characteristics (e.g., gender and\nrace) taking into account their latent abilities. However, the large sample\nsize, substantial covariate dimension, and great test length pose challenges to\ndeveloping efficient methods and drawing valid inferences. Moreover, to\naccommodate the commonly encountered discrete types of responses, nonlinear\nlatent factor models are often assumed, bringing further complexity to the\nproblem. To address these challenges, we consider a covariate-adjusted\ngeneralized factor model and develop novel and interpretable conditions to\naddress the identifiability issue. Based on the identifiability conditions, we\npropose a joint maximum likelihood estimation method and establish estimation\nconsistency and asymptotic normality results for the covariate effects under a\npractical yet challenging asymptotic regime. Furthermore, we derive estimation\nand inference results for latent factors and the factor loadings. We illustrate\nthe finite sample performance of the proposed method through extensive\nnumerical studies and an application to an educational assessment dataset\nobtained from the Programme for International Student Assessment (PISA).",
+    "authors": "Jing Ouyang, Chengyu Cui, Kean Ming Tan, Gongjun Xu",
+    "published": "2024-04-25",
+    "updated": "2024-04-25",
+    "primary_cat": "stat.ME",
+    "cats": [
+        "stat.ME"
+    ],
+    "label": "Original Paper",
+    "paper_cat": "LLM Fairness",
+    "gt": "Statistical Inference for Covariate-Adjusted and Interpretable Generalized Factor Model with Application to Testing Fairness",
+    "main_content": "Introduction Latent factors, often referred to as hidden factors, play an increasingly important role in modern statistics to analyze large-scale complex measurement data and find wide-ranging applications across various scientific fields, including educational assessments (Reckase 2009, Hambleton & Swaminathan 2013), macroeconomics forecasting (Stock & Watson 2002, Lam et al. 2011), and biomedical diagnosis (Carvalho et al. 2008, Frichot et al. 2013). For instance, in educational testing and social sciences, latent factors are used to model unobservable traits of respondents, such as skills, personality, and attitudes (von Davier Matthias 2008, Reckase 2009); in biology and genomics, latent factors are used to capture underlying genetic factors, gene expression patterns, or hidden biological mechanisms (Carvalho et al. 2008, Frichot et al. 2013). To uncover the latent factors and analyze large-scale complex data, various latent factor models have been developed and extensively investigated in the existing literature (Bai 2003, Bai & Li 2012, Fan et al. 2013, Chen et al. 2023b, Wang 2022). In addition to measuring the latent factors, the observed covariates and the covariate effects conditional on the latent factors hold significant scientific interpretations in many applications (Reboussin et al. 2008, Park et al. 2018). One important application is testing fairness, which receives increasing attention in the fields of education, psychology, and social sciences (Candell & Drasgow 1988, Belzak & Bauer 2020, Chen et al. 2023a). In educational assessments, testing fairness, or measurement invariance, implies that groups from diverse backgrounds have the same probability of endorsing the test items, controlling for individual proficiency levels (Millsap 2012). Testing fairness is not only of scientific interest to psychometricians and statisticians but also attracts widespread public awareness (Toch 1984). In the era of rapid technological advancements, international and large-scale educational assessments are becoming increasingly prevalent. One example is the Programme for International Student Assessment (PISA), which is a large-scale international assessment with substantial sample size and test length (OECD 2019). PISA assesses the knowledge and skills of 15-year-old students in mathematics, reading, and science domains (OECD 2 \f2019). In PISA 2018, over 600,000 students from 37 OECD1 countries and 42 partner countries/economies participated in the test (OECD 2019). To assess fairness of the test designs in such large-scale assessments, it is important to develop modern and computationally efficient methodologies for interpreting the effects of observed covariates (e.g., gender and race) on the item responses, controlling for the latent factors. However, the discrete nature of the item responses, the increasing sample size, and the large amount of test items in modern educational assessments pose great challenges for the estimation and inference for the covariate effects as well as for the latent factors. For instance, in educational and psychological measurements, such a testing fairness issue (measurement invariance) is typically assessed by differential item functioning (DIF) analysis of item response data that aims to detect the DIF items, where a DIF item has a response distribution that depends on not only the measured latent factors but also respondents\u2019 covariates (such as group membership). Despite many statistical methods that have been developed for DIF analysis, existing methods often require domain knowledge to pre-specify DIF-free items, namely anchor items, which may be misspecified and lead to biased estimation and inference results (Thissen 1988, Tay et al. 2016). To address this limitation, researchers developed item purification methods to iteratively select anchor items through stepwise selection models (Candell & Drasgow 1988, Fidalgo et al. 2000, Kopf et al. 2015). More recently, tree-based methods (Tutz & Berger 2016), regularized estimation methods (Bauer et al. 2020, Belzak & Bauer 2020, Wang et al. 2023), item pair functioning methods (Bechger & Maris 2015), and many other non-anchor-based methods have been proposed. However, these non-anchorbased methods do not provide valid statistical inference guarantees for testing the covariate effects. It remains an open problem to perform statistical inference on the covariate effects and the latent factors in educational assessments. To address this open problem, we study the statistical estimation and inference for a general family of covariate-adjusted nonlinear factor models, which include the popular factor 1OECD: Organisation for Economic Co-operation and Development 3 \fmodels for binary, count, continuous, and mixed-type data that commonly occur in educational assessments. The nonlinear model setting poses great challenges for estimation and statistical inference. Despite recent progress in the factor analysis literature, most existing studies focus on estimation and inference under linear factor models (Stock & Watson 2002, Bai & Li 2012, Fan et al. 2013) and covariate-adjusted linear factor models (Leek & Storey 2008, Wang et al. 2017, Gerard & Stephens 2020, Bing et al. 2024). The techniques employed in linear factor model settings are not applicable here due to the nonlinearity inherent in the general models under consideration. Recently, several researchers have also investigated the parameter estimation and inference for generalized linear factor models (Chen et al. 2019, Wang 2022, Chen et al. 2023b). However, they either focus only on the overall consistency properties of the estimation or do not incorporate covariates into the models. In a concurrent work, motivated by applications in single-cell omics, Du et al. (2023) considered a generalized linear factor model with covariates and studied its inference theory, where the latent factors are used as surrogate variables to control for unmeasured confounding. However, they imposed relatively stringent assumptions on the sparsity of covariate effects and the dimension of covariates, and their theoretical results also rely on data-splitting. Moreover, Du et al. (2023) focused only on statistical inference on the covariate effects, while that on factors and loadings was unexplored, which is often of great interest in educational assessments. Establishing inference results for covariate effects and latent factors simultaneously under nonlinear models remains an open and challenging problem, due to the identifiability issue from the incorporation of covariates and the nonlinearity issue in the considered general models. To overcome these issues, we develop a novel framework for performing statistical inference on all model parameters and latent factors under a general family of covariate-adjusted generalized factor models. Specifically, we propose a set of interpretable and practical identifiability conditions for identifying the model parameters, and further incorporate these conditions into the development of a computationally efficient likelihood-based estimation 4 \fmethod. Under these identifiability conditions, we develop new techniques to address the aforementioned theoretical challenges and obtain estimation consistency and asymptotic normality for covariate effects under a practical yet challenging asymptotic regime. Furthermore, building upon these results, we establish estimation consistency and provide valid inference results for factor loadings and latent factors that are often of scientific interest, advancing our theoretical understanding of nonlinear latent factor models. The rest of the paper is organized as follows. In Section 2, we introduce the model setup of the covariate-adjusted generalized factor model. Section 3 discusses the associated identifiability issues and further presents the proposed identifiability conditions and estimation method. Section 4 establishes the theoretical properties for not only the covariate effects but also the latent factors and factor loadings. In Section 5, we perform extensive numerical studies to illustrate the performance of the proposed estimation method and the validity of the theoretical results. In Section 6, we analyze an educational testing dataset from Programme for International Student Assessment (PISA) and identify test items that may lead to potential bias among different test-takers. We conclude with providing some potential future directions in Section 7. Notation: For any integer N, let [N] = {1, . . . , N}. For any set S, let #S be its cardinality. For any vector r = (r1, . . . , rl)\u22ba, let \u2225r\u22250 = #({j : rj \u0338= 0}), \u2225r\u2225\u221e= maxj=1,...,l |rj|, and \u2225r\u2225q = (Pl j=1 |rj|q)1/q for q \u22651. We define 1(y) x to be the y-dimensional vector with x-th entry to be 1 and all other entries to be 0. For any symmetric matrix M, let \u03bbmin(M) and \u03bbmax(M) be the smallest and largest eigenvalues of M. For any matrix A = (aij)n\u00d7l, let \u2225A\u2225\u221e,1 = maxj=1,...,l Pn i=1 |aij| be the maximum absolute column sum, \u2225A\u22251,\u221e= maxi=1,...,n Pl j=1 |aij| be the maximum of the absolute row sum, \u2225A\u2225max = maxi,j |aij| be the maximum of the absolute matrix entry, \u2225A\u2225F = (Pn i=1 Pl j=1 |aij|2)1/2 be the Frobenius norm of A, and \u2225A\u2225= p \u03bbmax (A\u22baA) be the spectral norm of A. Let \u2225\u00b7 \u2225\u03c61 be subexponential norm. Define the notation Av = vec(A) \u2208Rnl to indicate the vectorized matrix 5 \fA \u2208Rn\u00d7l. Finally, we denote \u2297as the Kronecker product. 2 Model Setup Consider n independent subjects with q measured responses and p\u2217observed covariates. For the ith subject, let Yi \u2208Rq be a q-dimensional vector of responses corresponding to q measurement items and Xc i \u2208Rp\u2217be a p\u2217-dimensional vector of observed covariates. Moreover, let Ui be a K-dimensional vector of latent factors representing the unobservable traits such as skills and personalities, where we assume K is specified as in many educational assessments. We assume that the q-dimensional responses Yi are conditionally independent, given Xc i and Ui. Specifically, we model the jth response for the ith subject, Yij, by the following conditional distribution: Yij \u223cpij(y | wij), where wij = \u03b2j0 + \u03b3\u22ba j Ui + \u03b2\u22ba jcXc i . (1) Here \u03b2j0 \u2208R is the intercept parameter, \u03b2jc = (\u03b2j1, . . . , \u03b2jp\u2217)\u22ba\u2208Rp\u2217are the coefficient parameters for the observed covariates, and \u03b3j = (\u03b3j1, . . . , \u03b3jK)\u22ba\u2208RK are the factor loadings. For better presentation, we write \u03b2j = (\u03b2j0, \u03b2\u22ba jc)\u22baas an assembled vector of intercept and coefficients and define Xi = (1, (Xc i )\u22ba)\u22bawith dimension p = p\u2217+ 1, which gives wij = \u03b3\u22ba j Ui + \u03b2\u22ba j Xi. Given wij, the function pij is some specified probability density (mass) function. Here, we consider a general and flexible modeling framework by allowing different types of pij functions to model diverse response data in wide-ranging applications, such as binary item response data in educational and psychological assessments (Mellenbergh 1994, Reckase 2009) and mixed types of data in educational and macroeconomic applications (Rijmen et al. 2003, Wang 2022); see also Remark 1. A schematic diagram of the proposed model setup is 6 \fpresented in Figure 1. Xi Yi1 Ui Yi2 Yi,q\u22121 Yiq \u2026 \u2026 \u03b21 \u03b22 \u03b2q\u22121 \u03b2q \u2026 \u03b31 \u03b32 \u03b3q\u22121 \u03b3q \u2026 Xi \u2208Rp Ui \u2208RK Yij \u2208R, j \u2208[q] Figure 1: A schematic diagram of the proposed model in (1). The subscript i indicates the ith subject, out of n independent subjects. The response variable Yij can be discrete or continuous. Our proposed covariate-adjusted generalized factor model in (1) is motivated by applications in testing fairness. In the context of educational assessment, the subject\u2019s responses to questions are dependent on latent factors Ui such as students\u2019 abilities and skills, and are potentially affected by observed covariates Xc i such as age, gender, and race, among others (Linda M. Collins 2009). The intercept \u03b2j0 is often interpreted as the difficulty level of item j and referred to as the difficulty parameter in psychometrics (Hambleton & Swaminathan 2013, Reckase 2009). The capability of item j to further differentiate individuals based on their latent abilities is captured by \u03b3j = (\u03b3j1, . . . , \u03b3jK)\u22ba, which are also referred to as discrimination parameters (Hambleton & Swaminathan 2013, Reckase 2009). The effects of observed covariates Xc i on subject\u2019s response to the jth question Yij, conditioned on latent abilities Ui, are captured by \u03b2jc = (\u03b2j1, . . . , \u03b2jp\u2217)\u22ba, which are referred to as DIF effects in psychometrics (Holland & Wainer 2012). This setting gives rise to the fairness problem of validating whether the response probabilities to the measurements differ across different genders, races, or countries of origin while holding their abilities and skills at the same level. 7 \fGiven the observed data from n independent subjects, we are interested in studying the relationships between Yi and Xc i after adjusting for the latent factors Ui in (1). Specifically, our goal is to test the statistical hypothesis H0 : \u03b2js = 0 versus Ha : \u03b2js \u0338= 0 for s \u2208[p\u2217], where \u03b2js is the regression coefficient for the sth covariate and the jth response, after adjusting for the latent factor Ui. In many applications, the latent factors and factor loadings also carry important scientific interpretations such as students\u2019 abilities and test items\u2019 characteristics. This motivates us to perform statistical inference on the parameters \u03b2j0, \u03b3j, and Ui as well. Remark 1. The proposed model setup (1) is general and flexible as various functions pij\u2019s could be used to model diverse types of response data in wide-ranging applications. For instance, in educational assessments, logistic factor model (Reckase 2009) with pij(y | wij) = exp(wijy)/{1 + exp(wij)}, y \u2208{0, 1} and probit factor model (Birnbaum 1968) with pij(y | wij) = {\u03a6(wij)}y{1 \u2212\u03a6(wij)}1\u2212y, y \u2208{0, 1} where \u03a6(\u00b7) is the cumulative density function of standard normal distribution, are widely used to model the binary responses, indicating correct or incorrect answers to the test items. Such types of models are often referred to as item response theory models (Reckase 2009). In economics and finances, linear factor models with pij(y | wij) \u221dexp{\u2212(y \u2212wij)2/(2\u03c32)}, where y \u2208R and \u03c32 is the variance parameter, are commonly used to model continuous responses, such as GDP, interest rate, and consumer index (Bai 2003, Bai & Li 2012, Stock & Watson 2016). Moreover, depending on the the observed responses, different types of function pij\u2019s can be used to model the response from each item j \u2208[q]. Therefore, mixed types of data, which are common in educational measurements (Rijmen et al. 2003) and macroeconomic applications (Wang 2022), can also be analyzed by our proposed model. 8 \fRemark 2. In addition to testing fairness, the considered model finds wide-ranging applications in the real world. For instance, in genomics, the gene expression status may depend on unmeasured confounders or latent biological factors and also be associated with the variables of interest including medical treatment, disease status, and gender (Wang et al. 2017, Du et al. 2023). The covariate-adjusted general factor model helps to investigate the effects of the variables of interest on gene expressions, controlling for the latent factors (Du et al. 2023). This setting is also applicable to other scenarios, such as brain imaging, where the activity of a brain region may depend on measurable spatial distance from neighboring regions and latent structures due to unmodeled factors (Leek & Storey 2008). To analyze large-scale measurement data, we aim to develop a computationally efficient estimation method and to provide inference theory for quantifying uncertainty in the estimation. Motivated by recent work in high-dimensional factor analysis, we treat the latent factors as fixed parameters and apply a joint maximum likelihood method for estimation (Bai 2003, Fan et al. 2013, Chen et al. 2020). Specifically, we let the collection of the item responses from n independent subjects be Y = (Y1, . . . , Yn)\u22ba n\u00d7q and the design matrix of observed covariates to be X = (X1, . . . , Xn)\u22ba n\u00d7p. For model parameters, the discrimination parameters for all q items are denoted as \u0393 = (\u03b31, . . . , \u03b3q)\u22ba q\u00d7K, while the intercepts and the covariate effects for all q items are denoted as B = (\u03b21, . . . , \u03b2q)\u22ba q\u00d7p. The latent factors from all n subjects are U = (U1, . . . , Un)\u22ba n\u00d7K. Then, the joint log-likelihood function can be written as follows: L(Y | \u0393, U, B, X) = 1 nq n X i=1 q X j=1 lij(\u03b2j0 + \u03b3\u22ba j Ui + \u03b2\u22ba jcXc i ), (2) where the function lij(wij) = log pij(Yij|wij) is the individual log-likelihood function with wij = \u03b2j0 + \u03b3\u22ba j Ui + \u03b2\u22ba jcXc i . We aim to obtain (b \u0393, b U, b B) from maximizing the joint likelihood function L(Y | \u0393, U, B, X). While the estimators can be computed efficiently by maximizing the joint likelihood 9 \ffunction through an alternating maximization algorithm (Collins et al. 2002, Chen et al. 2019), challenges emerge for performing statistical inference on the model parameters. \u2022 One challenge concerns the model identifiability. Without additional constraints, the covariate effects are not identifiable due to the incorporation of covariates and their potential dependence on latent factors. The latent factors and factor loadings encounter similar identifiability issues as in traditional factor analysis (Bai & Li 2012, Fan et al. 2013). Ensuring that the model is statistically identifiable is the fundamental prerequisite for achieving model reliability and making valid inferences (Allman et al. 2009, Gu & Xu 2020). \u2022 Another challenge arises from the nonlinearity of our proposed model. In the existing literature, most studies focus on the statistical inference for our proposed setting in the context of linear models (Bai & Li 2012, Fan et al. 2013, Wang et al. 2017). On the other hand, settings with general log-likelihood function lij(wij), including covariateadjusted logistic and probit factor models, are less investigated. Common techniques for linear models are not applicable to the considered general nonlinear model setting. Motivated by these challenges, we propose interpretable and practical identifiability conditions in Section 3.1. We then incorporate these conditions into the joint-likelihood-based estimation method in Section 3.2. Furthermore, we introduce a novel inference framework for performing statistical inference on \u03b2j, \u03b3j, and Ui in Section 4. 3 Method 3.1 Model Identifiability Identifiability issues commonly occur in latent variable models (Allman et al. 2009, Bai & Li 2012, Xu 2017). The proposed model in (1) has two major identifiability issues. The first issue is that the proposed model remains unchanged after certain linear transformations of 10 \fboth B and U, causing the covariate effects together with the intercepts, represented by B, and the latent factors, denoted by U, to be unidentifiable. The second issue is that the model is invariant after an invertible transformation of both U and \u0393 as in the linear factor models (Bai & Li 2012, Fan et al. 2013), causing the latent factors U and factor loadings \u0393 to be undetermined. Specifically, under the model setup in (1), we define the joint probability distribution of responses to be P(Y | \u0393, U, B, X) = Qn i=1 Qq j=1 pij(Yij|wij). The model parameters are identifiable if and only if for any response Y, there does not exist (\u0393, U, B) \u0338= (e \u0393, e U, e B) such that P(Y | \u0393, U, B, X) = P(Y | e \u0393, e U, e B, X). The first issue concerning the identifiability of B and U is that for any (\u0393, U, B) and any transformation matrix A, there exist e \u0393 = \u0393, e U = U + XA\u22ba, and e B = B \u2212\u0393A such that P(Y | \u0393, U, B, X) = P(Y | e \u0393, e U, e B, X). This identifiability issue leads to the indeterminacy of the covariate effects and latent factors. The second issue is related to the identifiability of U and \u0393. For any (e \u0393, e U, e B) and any invertible matrix G, there exist \u00af \u0393 = e \u0393(G\u22ba)\u22121, \u00af U = e UG, and \u00af B = e B such that P(Y | e \u0393, e U, e B, X) = P(Y | \u00af \u0393, \u00af U, \u00af B, X). This causes the latent factors and factor loadings to be unidentifiable. Remark 3. Intuitively, the unidentifiable e B = B \u2212\u0393A can be interpreted to include both direct and indirect effects of X on response Y. We take the intercept and covariate effect on the first item ( e \u03b21) as an example and illustrate it in Figure 2. One part of e \u03b21 is the direct effect from X onto Y (see the orange line in the left panel), whereas another part of e \u03b21 may be explained through the latent factors U, as the latent factors are unobserved and there are potential correlations between latent factors and observed covariates. The latter part of e \u03b21 can be considered as the indirect effect (see the blue line in the right panel). 11 \fXi Yi1 Ui Yi2 Yi,q\u22121 Yiq \u2026 \u2026 \u03b21 \u03b22 \u03b2q\u22121 \u03b2q \u2026 \u03b31 \u03b32 \u03b3q\u22121 \u03b3q \u2026 Xi Yi1 Ui Yi2 Yi,q\u22121 Yiq \u2026 \u2026 \u03b21 \u03b22 \u03b2q\u22121 \u03b2q \u2026 \u03b31 \u03b32 \u03b3q\u22121 \u03b3q \u2026 Figure 2: The direct effects (orange solid line in the left panel) and the indirect effects (blue solid line in the right panel) for item 1. The first identifiability issue is a new challenge introduced by the covariate adjustment in the model, whereas the second issue is common in traditional factor models (Bai & Li 2012, Fan et al. 2013). Considering the two issues together, for any (\u0393, U, B), A, and G, there exist transformations e \u0393 = \u0393(G\u22ba)\u22121, e U = (U + XA\u22ba)G, and e B = B \u2212\u0393A such that P(Y | \u0393, U, B, X) = P(Y | e \u0393, e U, e B, X). In the rest of this subsection, we propose identifiability conditions to address these issues. For notation convenience, throughout the rest of the paper, we define \u03d5\u2217= (\u0393\u2217, U\u2217, B\u2217) as the true parameters. Identifiability Conditions As described earlier, the correlation between the design matrix of covariates X and the latent factors U\u2217results in the identifiability issue of B\u2217. In the psychometrics literature, the intercept \u03b2\u2217 j0 is commonly referred to as the difficulty parameter, while \u03b2\u2217 jc represents the effects of observed covariates, namely DIF effects, on the response to item j (Reckase 2009, Holland & Wainer 2012). The different scientific interpretations motivate us to develop different identifiability conditions for \u03b2\u2217 j0 and \u03b2\u2217 jc, respectively. Specifically, we propose a centering condition on U\u2217to ensure the identifiability of the intercept \u03b2\u2217 j0 for all items j \u2208[q]. On the other hand, to identify the covariate effects \u03b2\u2217 jc, a natural idea is to impose the covariate effects \u03b2\u2217 jc for all items j \u2208[q] to be sparse, as shown in many regularized methods and item purification methods (Candell & Drasgow 1988, Fidalgo et al. 2000, Bauer et al. 2020, Belzak & Bauer 2020). In Chen et al. (2023a), 12 \fan interpretable identifiability condition is proposed for selecting sparse covariate effects, yet this condition is specific to uni-dimensional covariates. Motivated by Chen et al. (2023a), we propose the following minimal \u21131 condition applicable to general cases where the covariates are multi-dimensional. To better present the identifiability conditions, we write A = (a0, a1, . . . , ap\u2217) \u2208RK\u00d7p and define Ac = (a1, . . . , ap\u2217) \u2208RK\u00d7p\u2217as the part applied to the covariate effects. Condition 1. (i) Pn i=1 U \u2217 i = 0K. (ii) Pq j=1 \u2225\u03b2\u2217 jc\u22251 < Pq j=1 \u2225\u03b2\u2217 jc \u2212A\u22ba c\u03b3\u2217 j \u22251 for any Ac \u0338= 0. Condition 1(i) assumes the latent abilities U\u2217are centered to ensure the identifiability of the intercepts \u03b2\u2217 j0\u2019s, which is commonly assumed in the item response theory literature (Reckase 2009). Condition 1(ii) is motivated by practical applications. For instance, in educational testing, practitioners need to identify and remove biased test items, correspondingly, items with non-zero covariate effects (\u03b2\u2217 js \u0338= 0). In practice, most of the designed items are unbiased, and therefore, it is reasonable to assume that the majority of items have no covariate effects, that is, the covariate effects \u03b2\u2217 jc\u2019s are sparse (Holland & Wainer 2012, Chen et al. 2023a). Next, we present a sufficient and necessary condition for Condition 1(ii) to hold. Proposition 1. Condition 1(ii) holds if and only if for any v \u2208RK \\ {0K}, q X j=1 \f \fv\u22ba\u03b3\u2217 j \f \fI(\u03b2\u2217 js = 0) > q X j=1 sign(\u03b2\u2217 js)v\u22ba\u03b3\u2217 j I(\u03b2\u2217 js \u0338= 0), \u2200s \u2208[p\u2217]. (3) Remark 4. Proposition 1 implies that Condition 1(ii) holds when {j : \u03b2\u2217 js \u0338= 0} is separated into {j : \u03b2\u2217 js > 0} and {j : \u03b2\u2217 js < 0} in a balanced way. With diversified signs of \u03b2\u2217 js, Proposition 1 holds when a considerable proportion of test items have no covariate effect (\u03b2\u2217 js \u0338= 0). For example, when \u03b3\u2217 j = m1(k) K with m > 0, Condition 1(ii) holds if and only if Pq j=1 |m|{\u2212I(\u03b2\u2217 js/m > 0) + I(\u03b2\u2217 js/m \u22640)} > 0 and Pq j=1 |m|{\u2212I(\u03b2\u2217 js/m \u22650) + I(\u03b2\u2217 js/m < 0)} < 0. With slightly more than q/2 items correspond to \u03b2\u2217 js = 0, Condition 1(ii) holds. Moreover, if #{j : \u03b2\u2217 js > 0} and #{j : \u03b2\u2217 js < 0} are comparable, then Condition 1(ii) holds even when less than q/2 items correspond to \u03b2\u2217 js = 0 and more than q/2 items correspond 13 \fto \u03b2\u2217 js \u0338= 0. Though assuming a \u201csparse\u201d structure, our assumption here differs from existing high-dimensional literature. In high-dimensional regression models, the covariate coefficient when regressing the dependent variable on high-dimensional covariates, is often assumed to be sparse, with the proportion of the non-zero covariate coefficients asymptotically approaching zero. In our setting, Condition 1(ii) allows for relatively dense settings where the proportion of items with non-zero covariate effects is some positive constant. To perform simultaneous estimation and inference on \u0393\u2217and U\u2217, we consider the following identifiability conditions to address the second identifiability issue. Condition 2. (i) (U\u2217)\u22baU\u2217is diagonal. (ii) (\u0393\u2217)\u22ba\u0393\u2217is diagonal. (iii) n\u22121(U\u2217)\u22baU\u2217= q\u22121(\u0393\u2217)\u22ba\u0393\u2217. Condition 2 is a set of widely used identifiability conditions in the factor analysis literature (Bai 2003, Bai & Li 2012, Wang 2022). For practical and theoretical benefits, we impose Condition 2 to address the identifiability issue related to G. It is worth mentioning that this condition can be replaced by other identifiability conditions. For true parameters satisfying any identifiability condition, we can always find a transformation such that the transformed parameters satisfy our proposed Conditions 1\u20132 and the proposed estimation method and theoretical results in the subsequent sections still apply, up to such a transformation. 3.2 Joint Maximum Likelihood Estimation In this section, we introduce a joint-likelihood-based estimation method for the covariate effects B, the latent factors U, and factor loadings \u0393 simultaneously. Incorporating Conditions 1\u20132 into the estimation procedure, we obtain the maximum joint-likelihood-based estimators for \u03d5\u2217= (\u0393\u2217, U\u2217, B\u2217) that satisfy the proposed identifiability conditions. With Condition 1, we address the identifiability issue related to the transformation matrix A. Specifically, for any parameters \u03d5 = (\u0393, U, B), there exists a matrix A\u2217= (a\u2217 0, A\u2217 c) with A\u2217 c = argminAc\u2208RK\u00d7p\u2217 Pq j=1 \u2225\u03b2jc \u2212A\u22ba c\u03b3j\u22251 and a\u2217 0 = \u2212n\u22121 Pn i=1(Ui + A\u2217 cXc i ) such that 14 \fthe transformed matrices U\u2217= U + X(A\u2217)\u22baand B\u2217= B \u2212\u0393A\u2217satisfy Condition 1. The transformation idea naturally leads to the following estimation methodology for B\u2217. To estimate B\u2217and U\u2217that satisfy Condition 1, we first obtain the maximum likelihood estimator b \u03d5 = (b \u0393, b U, b B) by b \u03d5 = argmin \u03d5\u2208\u2126\u03d5 \u2212L(Y | \u03d5, X), (4) where the parameter space \u2126\u03d5 is given as \u2126\u03d5 = {\u03d5 : \u2225\u03d5\u2225max \u2264C} for some large C. To solve (4), we employ an alternating minimization algorithm. Specifically, for steps t = 0, 1, . . ., we compute b \u0393(t+1), b B(t+1) = argmin \u0393\u2208Rq\u00d7K, B\u2208Rq\u00d7p \u2212L(Y | \u0393, U(t), B, X); b U(t+1) = argmin U\u2208Rn\u00d7K \u2212L(Y | \u0393(t+1), U, B(t+1), X), until the quantity max{\u2225b \u0393(t+1) \u2212b \u0393(t)\u2225F, \u2225b U(t+1) \u2212b U(t)\u2225F, \u2225b B(t+1) \u2212b B(t)\u2225F} is less than some pre-specified tolerance value for convergence. We then estimate Ac by minimizing the \u21131norm b Ac = argmin Ac\u2208RK\u00d7p\u2217 q X j=1 \u2225b \u03b2jc \u2212A\u22ba c b \u03b3j\u22251. (5) Next, we estimate b a0 = \u2212n\u22121 Pn i=1( b Ui + b AcXc i ) and let b A = (b a0, b Ac). Given the estimators b A, b \u0393, and b B, we then construct b B\u2217= b B \u2212b \u0393b A and e U = b U + Xb A\u22ba such that Condition 1 holds. Recall that Condition 2 addresses the identifiability issue related to the invertible matrix G. Specifically, for any parameters (\u0393, U), there exists a matrix G\u2217such that Condition 2 holds for U\u2217= (U+X(A\u2217)\u22ba)G\u2217and \u0393\u2217= \u0393(G\u2217)\u2212\u22ba. Let U = diag(\u03f11, . . . , \u03f1K) be a diagonal 15 \fmatrix that contains the K eigenvalues of (nq)\u22121(\u0393\u22ba\u0393)1/2(U + XA\u22ba)\u22ba(U + XA\u22ba) (\u0393\u22ba\u0393)1/2 and let V be a matrix that contains its corresponding eigenvectors. We set G\u2217= (q\u22121\u0393\u22ba\u0393)1/2 VU \u22121/4. To further estimate \u0393\u2217and U\u2217, we need to obtain an estimator for the invertible matrix G\u2217. Given the maximum likelihood estimators obtained in (4) and b A in (5), we estimate G\u2217via b G = (q\u22121b \u0393\u22bab \u0393)1/2 b V b U \u22121/4 where b U and b V are matrices that contain the eigenvalues and eigenvectors of (nq)\u22121(b \u0393\u22bab \u0393)1/2( b U+Xb A\u22ba)\u22ba( b U+Xb A\u22ba) (b \u0393\u22bab \u0393)1/2, respectively. With b G and b A, we now obtain the following transformed estimators that satisfy Condition 2: b \u0393\u2217= b \u0393( b G\u22ba)\u22121 and b U\u2217= ( b U + Xb A\u22ba) b G. To quantify the uncertainty of the proposed estimators, we will show that the proposed estimators are asymptotically normally distributed. Specifically, in Theorem 2 of Section 4, we establish the asymptotic normality result for b \u03b2\u2217 j, which allows us to make inference on the covariate effects \u03b2\u2217 j. Moreover, as the latent factors U \u2217 i and factor loadings \u03b3\u2217 j often have important interpretations in domain sciences, we are also interested in the inference on parameters U \u2217 i and \u03b3\u2217 j . In Theorem 2, we also derive the asymptotic distributions for estimators b U \u2217 i and b \u03b3\u2217 j , providing inference results for parameters U \u2217 i and \u03b3\u2217 j . 4 Theoretical Results We propose a novel framework to establish the estimation consistency and asymptotic normality for the proposed joint-likelihood-based estimators b \u03d5\u2217= (b \u0393\u2217, b U\u2217, b B\u2217) in Section 3. To establish the theoretical results for b \u03d5\u2217, we impose the following regularity assumptions. Assumption 1. There exist constants M > 0, \u03ba > 0 such that: (i) \u03a3\u2217 u = limn\u2192\u221en\u22121(U\u2217)\u22baU\u2217exists and is positive definite. For i \u2208[n], \u2225U \u2217 i \u22252 \u2264M. (ii) \u03a3\u2217 \u03b3 = limq\u2192\u221eq\u22121(\u0393\u2217)\u22ba\u0393\u2217exists and is positive definite. For j \u2208[q], \u2225\u03b3\u2217 j \u22252 \u2264M. (iii) \u03a3x = limn\u2192\u221en\u22121 Pn i=1 XiX\u22ba i exists and 1/\u03ba2 \u2264\u03bbmin(\u03a3x) \u2264\u03bbmax(\u03a3x) \u2264\u03ba2. For i \u2208[n], maxi \u2225Xi\u2225\u221e\u2264M. 16 \f(iv) \u03a3\u2217 ux = limn\u2192\u221en\u22121 Pn i=1 U \u2217 i X\u22ba i exists and \u2225\u03a3\u2217 ux\u03a3\u22121 x \u22251,\u221e\u2264M. The eigenvalues of (\u03a3\u2217 u \u2212\u03a3\u2217 ux\u03a3\u22121 x (\u03a3\u2217 ux)\u22ba)\u03a3\u2217 \u03b3 are distinct. Assumptions 1 is commonly used in the factor analysis literature. In particular, Assumptions 1(i)\u2013(ii) correspond to Assumptions A-B in Bai (2003) under linear factor models, ensuring the compactness of the parameter space on U\u2217and \u0393\u2217. Under nonlinear factor models, such conditions on compact parameter space are also commonly assumed (Wang 2022, Chen et al. 2023b). Assumption 1(iii) is standard regularity conditions for the nonlinear setting that is needed to establish the concentration of the gradient and estimation error for the model parameters when p diverges. In addition, Assumption 1(iv) is a crucial identification condition; similar conditions have been imposed in the existing literature such as Assumption G in Bai (2003) in the context of linear factor models and Assumption 6 in Wang (2022) in the context of nonlinear factor models without covariates. Assumption 2. For any i \u2208[n] and j \u2208[q], assume that lij(\u00b7) is three times differentiable, and we denote the first, second, and third order derivatives of lij(wij) with respect to wij as l\u2032 ij(wij), l\u2032\u2032 ij(wij), and l\u2032\u2032\u2032 ij(wij), respectively. There exist M > 0 and \u03be \u22654 such that E(|l\u2032 ij(wij)|\u03be) \u2264M and |l\u2032 ij(wij)| is sub-exponential with \u2225l\u2032 ij(wij)\u2225\u03c61 \u2264M. Furthermore, we assume E{l\u2032 ij(w\u2217 ij)} = 0. Within a compact space of wij, we have bL \u2264\u2212l\u2032\u2032 ij(wij) \u2264bU and |l\u2032\u2032\u2032 ij(wij)| \u2264bU for bU > bL > 0. Assumption 2 assumes smoothness on the log-likelihood function lij(wij). In particular, it assumes sub-exponential distributions and finite fourth-moments of the first order derivatives l\u2032 ij(wij). For commonly used linear or nonlinear factor models, the assumption is not restrictive and can be satisfied with a large \u03be. For instance, consider the logistic model with l\u2032 ij(wij) = Yij \u2212exp(wij)/{1+exp(wij)}, we have |l\u2032 ij(wij)| \u22641 and \u03be can be taken as \u221e. The boundedness conditions for l\u2032\u2032 ij(wij) and l\u2032\u2032\u2032 ij(wij) are necessary to guarantee the convexity of the joint likelihood function. In a special case of linear factor models, l\u2032\u2032 ij(wij) is a constant and the boundedness conditions naturally hold. For popular nonlinear models such as lo17 \fgistic factor models, probit factor models, and Poisson factor models, the boundedness of l\u2032\u2032 ij(wij) and l\u2032\u2032\u2032 ij(wij) can also be easily verified. Assumption 3. For \u03be specified in Assumption 2 and a sufficiently small \u03f5 > 0, we assume as n, q, p \u2192\u221e, p p n \u2227(pq) (nq)\u03f5+3/\u03be \u21920. (6) Assumption 3 is needed to ensure that the derivative of the likelihood function equals zero at the maximum likelihood estimator with high probability, a key property in the theoretical analysis. In particular, we need the estimation errors of all model parameters to converge to 0 uniformly with high probability. Such uniform convergence results involve delicate analysis of the convexity of the objective function, for which technically we need Assumption 3. For most of the popularly used generalized factor models, \u03be can be taken as any large value as discussed above, thus (nq)\u03f5+3/\u03be is of a smaller order of p n \u2227(pq), given small \u03f5. Specifically, Assumption 3 implies p = o(n1/2 \u2227q) up to a small order term, an asymptotic regime that is reasonable for many educational assessments. Next, we impose additional assumptions crucial to establishing the theoretical properties of the proposed estimators. One challenge for theoretical analysis is to handle the dependence between the latent factors U\u2217and the design matrix X. To address this challenge, we employ the following transformed U0 that are orthogonal with X, which plays an important role in establishing the theoretical results (see Supplementary Materials for details). In particular, for i \u2208[n], we let U 0 i = (G\u2021)\u22ba(U \u2217 i \u2212A\u2021Xi). Here G\u2021 = (q\u22121(\u0393\u2217)\u22ba\u0393\u2217)1/2 V\u2217(U \u2217)\u22121/4 and A\u2021 = (U\u2217)\u22baX(X\u22baX)\u22121, where U \u2217= diag(\u03f1\u2217 1, . . . , \u03f1\u2217 K) with diagonal elements being the K eigenvalues of (nq)\u22121((\u0393\u2217)\u22ba\u0393\u2217)1/2(U\u2217)\u22ba(In\u2212Px)U\u2217((\u0393\u2217)\u22ba\u0393\u2217)1/2 with Px = X(X\u22baX)\u22121X\u22baand V\u2217containing the matrix of corresponding eigenvectors. Under this transformation for U 0 i , we further define \u03b30 j = (G\u2021)\u22121\u03b3\u2217 j and \u03b20 j = \u03b2\u2217 j + (A\u2021)\u22ba\u03b3\u2217 j for j \u2208[q], and write Z0 i = ((U 0 i )\u22ba X\u22ba i )\u22baand w0 ij = (\u03b30 j )\u22baU 0 i + (\u03b20 j)\u22baXi. These transformed parameters \u03b30 j \u2019s, U 0 i \u2019s, and \u03b20 j\u2019s give the same joint likelihood value as that of the true parameters \u03b3\u2217 j \u2019s, U \u2217 i \u2019s and \u03b2\u2217 j\u2019s, which 18 \ffacilitate our theoretical understanding of the joint-likelihood-based estimators. Assumption 4. (i) For any j \u2208[q], \u2212n\u22121 Pn i=1 l\u2032\u2032 ij(w0 ij)Z0 i (Z0 i )\u22ba p \u2192\u03a80 jz for some positive definite matrix \u03a80 jz and n\u22121/2 Pn i=1 l\u2032 ij(w0 ij)Z0 i d \u2192N(0, \u21260 jz). (ii) For any i \u2208[n], \u2212q\u22121 Pq j=1 l\u2032\u2032 ij(w0 ij)\u03b30 j (\u03b30 j )\u22ba p \u2192\u03a80 i\u03b3 for some positive definite matrix \u03a80 i\u03b3 and q\u22121/2 Pq j=1 l\u2032 ij(w0 ij)\u03b30 j d \u2192N(0, \u21260 i\u03b3). Assumption 4 is a generalization of Assumption F(3)-(4) in Bai (2003) for linear models to the nonlinear setting. Specifically, we need Assumption 4(i) to derive the asymptotic distributions of the estimators b \u03b2\u2217 j and b \u03b3\u2217 j , and Assumption 4(ii) is used for establishing the asymptotic distribution of b U \u2217 i . Note that these assumptions are imposed on the loglikelihood derivative functions evaluated at the true parameters w0 ij, Z0 i , and \u03b30 j . In general, for the popular generalized factor models, such assumptions hold with mild conditions. For example, under linear models, l\u2032 ij(wij) is the random error and l\u2032\u2032 ij(wij) is a constant. Then \u03a80 jz and \u03a80 i\u03b3 naturally exist and are positive definite followed by Assumption 1. The limiting distributions of n\u22121/2 Pn i=1 l\u2032 ij(w0 ij)Z0 i and q\u22121/2 Pq j=1 l\u2032 ij(w0 ij)\u03b30 j can be derived by the central limit theorem under standard regularity conditions. Under logistic and probit models, l\u2032 ij(wij) and l\u2032\u2032 ij(wij) are both finite inside a compact parameters space and similar arguments can be applied to show the validity of Assumption 4. We present the following assumption to establish the theoretical properties of the transformed matrix b A as defined in (5). In particular, we define A0 = (G\u2021)\u22baA\u2021 and write A0 = (a0 0, . . . , a0 p\u2217)\u22ba. Note that the estimation problem of (5) is related to the median regression problem with measurement errors. To understand the properties of this estimator, following existing M-estimation literature (He & Shao 1996, 2000), we define \u03c80 js(a) = \u03b30 j sign{\u03b20 js + (\u03b30 j )\u22ba(a \u2212a0 s)} and \u03c7s(a) = Pq j=1 \u03c80 js(a) for j \u2208[q] and s \u2208[p\u2217]. We further define a perturbed version of \u03c80 js(a), denoted as \u03c8js(a, \u03b4js), as follows: \u03c8js(a, \u03b4js) = \u0010 \u03b30 j + \u0002 \u03b4js \u221an \u0003 [1:K] \u0011 sign n \u03b20 js + \u0002 \u03b4js \u221an \u0003 K+1 \u2212(\u03b30 j + \u0002 \u03b4js \u221an \u0003 [1:K])\u22ba(a \u2212a0 s) o , s \u2208[p\u2217] 19 \fwhere the perturbation \u03b4js = \uf8eb \uf8ec \uf8ed IK 0 0 (1(p) s )\u22ba \uf8f6 \uf8f7 \uf8f8 \u0010 \u2212 n X i=1 l\u2032\u2032 ij(w0 ij)Z0 i (Z0 i )\u22ba\u0011\u22121\u0010\u221an n X i=1 l\u2032 ij(w0 ij)Z0 i \u0011 , is asymptotically normally distributed by Assumption 4. We define b \u03c7s(a) = Pq j=1 E\u03c8js(a, \u03b4js). Assumption 5. For \u03c7s(a), we assume that there exists some constant c > 0 such that mina\u0338=0 |q\u22121\u03c7s(a)| > c holds for all s \u2208[p\u2217]. Assume there exists as0 for each s \u2208[p\u2217] such that b \u03c7s(as0) = 0 with p\u221an\u2225\u03b1s0\u2225\u21920. In a neighbourhood of \u03b1s0, b \u03c7s(a) has a nonsingular derivative such that {q\u22121\u2207ab \u03c7s(\u03b1s0)}\u22121 = O(1) and q\u22121|\u2207ab \u03c7s(a)\u2212\u2207ab \u03c7s(\u03b1s0)| \u2264k|a\u2212\u03b1s0|. We assume \u03b9nq,p := max \b \u2225\u03b1s0\u2225, q\u22121 Pq j=1 \u03c8js(as0, \u03b4js) \t = o \u0000(p\u221an)\u22121\u0001 . Assumption 5 is crucial in addressing the theoretical difficulties of establishing the consistent estimation for A0, a challenging problem related to median regression with weakly dependent measurement errors. In Assumption 5, we treat the minimizer of | Pq j=1 \u03c8(a, \u03b4js)| as an M-estimator and adopt the Bahadur representation results in He & Shao (1996) for the theoretical analysis. For an ideal case where \u03b4js are independent and normally distributed with finite variances, which corresponds to the setting in median regression with measurement errors (He & Liang 2000), these assumptions can be easily verified. Assumption 5 discusses beyond such an ideal case and covers general settings. In addition to independent and Gaussian measurement errors, this condition also accommodates the case when \u03b4js are asymptotically normal and weakly dependent with finite variances, as implied by Assumption 4 and the conditional independence of Yij. We want to emphasize that Assumption 5 allows for both sparse and dense settings of the covariate effects. Consider an example of K = p = 1 and \u03b3j = 1 for j \u2208[q]. Suppose \u03b2\u2217 js is zero for all j \u2208[q1] and nonzero otherwise. Then this condition is satisfied as long as #{j : \u03b2\u2217 js > 0} and #{j : \u03b2\u2217 js < 0} are comparable, even when the sparsity level q1 is small. Under the proposed assumptions, we next present our main theoretical results. 20 \fTheorem 1 (Average Consistency). Suppose the true parameters \u03d5\u2217= (\u0393\u2217, U\u2217, B\u2217) satisfy identifiability conditions 1\u20132. Under Assumptions 1\u20135, we have q\u22121\u2225b B\u2217\u2212B\u2217\u22252 F = Op \u0012p2 log qp n + p log n q \u0013 ; (7) if we further assume p3/2(nq)\u03f5+3/\u03be(p1/2n\u22121/2 + q\u22121/2) = o(1), then we have n\u22121\u2225b U\u2217\u2212U\u2217\u22252 F = Op \u0012p log qp n + log n q \u0013 ; (8) q\u22121\u2225b \u0393\u2217\u2212\u0393\u2217\u22252 F = Op \u0012p log qp n + log n q \u0013 . (9) Theorem 1 presents the average convergence rates of b \u03d5\u2217. Consider an oracle case with U\u2217 and \u0393\u2217known, the estimation of B\u2217reduces to an M-estimation problem. For M-estimators under general parametric models, it can be shown that the optimal convergence rates in squared \u21132-norm is Op(p/n) under p(log p)3/n \u21920 (He & Shao 2000). In terms of our average convergence rate on b B\u2217, the first term in (7), n\u22121p2 log(qp), approximately matches the convergence rate Op(p/n) up to a relatively small order term of p log(qp). The second term in (7), q\u22121p log n, is mainly due to the estimation error for the latent factor U\u2217. In educational applications, it is common to assume the number of subjects n is much larger than the number of items q. Under such a practical setting with n \u226bq and p relatively small, the term q\u22121 log n in (8) dominates in the derived convergence rate of b U\u2217, which matches with the optimal convergence rate Op(q\u22121) for factor models without covariates (Bai & Li 2012, Wang 2022) up to a small order term. Remark 5. The additional condition p3/2(nq)\u03f5+3/\u03be(p1/2n\u22121/2 + q\u22121/2) = o(1) in Theorem 1 is used to handle the challenges related to the invertible matrix G that affects the theoretical properties of b U\u2217and b \u0393\u2217. It is needed for establishing the estimation consistency of b U\u2217and b \u0393\u2217 but not for that of b B\u2217. With sufficiently large \u03be and small \u03f5, this assumption is approximately p = o(n1/4 \u2227q1/3) up to a small order term. 21 \fRemark 6. One challenge in establishing the estimation consistency for b \u03d5\u2217arises from the unrestricted dependence structure between U\u2217and X. If we consider the ideal case where the columns of U\u2217and X are orthogonal, i.e., (U\u2217)\u22baX = 0K\u00d7p, then we can achieve comparable or superior convergence rates with less stringent assumptions. Specifically, with Assumptions 1\u20133 only, we can obtain the same convergence rates for b U\u2217and b \u0393\u2217as in (8) and (9), respectively. Moreover, with Assumptions 1\u20133, the average convergence rate for the consistent estimator of B\u2217is Op(n\u22121p log qp+q\u22121 log n), which is tighter than (7) by a factor of p. With estimation consistency results established, we next derive the asymptotic normal distributions for the estimators, which enable us to perform statistical inference on the true parameters. Theorem 2 (Asymptotic Normality). Suppose the true parameters \u03d5\u2217= (\u0393\u2217, U\u2217, B\u2217) satisfy identifiability conditions 1\u20132. Under Assumptions 1\u20135, we have the asymptotic distributions as follows. Denote \u03b6\u22122 nq,p = n\u22121p log qp + q\u22121log n. If p3/2\u221an(nq)3/\u03be\u03b6\u22122 nq,p \u21920, for any j \u2208[q] and a \u2208Rp with \u2225a\u22252 = 1, \u221ana\u22ba(\u03a3\u2217 \u03b2,j)\u22121/2( b \u03b2\u2217 j \u2212\u03b2\u2217 j) d \u2192N(0, 1), (10) where \u03a3\u2217 \u03b2,j = (\u2212(A0)\u22ba, Ip)(\u03a80 jz)\u22121\u21260 jz(\u03a80 jz)\u22121(\u2212(A0)\u22ba, Ip)\u22ba, and for any j \u2208[q], \u221an(\u03a3\u2217 \u03b3,j)\u22121/2(b \u03b3\u2217 j \u2212\u03b3\u2217 j ) d \u2192N(0, IK), (11) where \u03a3\u2217 \u03b3,j = G\u2021(IK, 0)(\u03a80 jz)\u22121\u21260 jz(\u03a80 jz)\u22121 (IK, 0)\u22ba(G\u2021)\u22ba. Furthermore, for any i \u2208[n], if q = O(n) and p3/2\u221aq(nq)3/\u03be\u03b6\u22122 nq,p \u21920, \u221aq(\u03a3\u2217 u,i)\u22121/2( b U \u2217 i \u2212U \u2217 i ) d \u2192N(0, IK), (12) where \u03a3\u2217 u,i = (G\u2021)\u2212\u22ba(\u03a80 i\u03b3)\u22121\u21260 i\u03b3(\u03a80 i\u03b3)\u22121(G\u2021)\u22121. 22 \fThe asymptotic covariance matrices in Theorem 2 can be consistently estimated. Due to the space limitations, we defer the construction of the consistent estimators b \u03a3\u2217 \u03b2,j, b \u03a3\u2217 \u03b3,j, and b \u03a3\u2217 u,i to Supplementary Materials. Theorem 2 provides the asymptotic distributions for all individual estimators. In particular, with the asymptotic distributions and the consistent estimators b \u03a3\u2217 \u03b2,j for the asymptotic covariance matrices, we can perform hypothesis testing on \u03b2\u2217 js for j \u2208[q] and s \u2208[p\u2217]. We reject the null hypothesis \u03b2\u2217 js = 0 at significance level \u03b1 if |\u221an(b \u03c3\u2217 \u03b2,js)\u22121b \u03b2\u2217 js| > \u03a6\u22121(1 \u2212\u03b1/2), where (b \u03c3\u2217 \u03b2,js)2 is the (s + 1)-th diagonal entry in b \u03a3\u2217 \u03b2,j. For the asymptotic normality of b \u03b2\u2217 j, the condition p3/2\u221an(nq)3/\u03be(n\u22121p log qp+q\u22121 log n) \u2192 0 together with Assumption 3 gives p = o{n1/5 \u2227(q2/n)1/3} up to a small order term, and further implies n \u226aq2, which is consistent with established conditions in the existing factor analysis literature (Bai & Li 2012, Wang 2022). For the asymptotic normality of b U \u2217 i , the additional condition that q = O(n) is a reasonable assumption in educational applications where the number of items q is much fewer than the number of subjects n. In this case, the scaling conditions imply p = o{q1/3 \u2227(n2/q)1/5} up to a small order term. Similarly for the asymptotic normality of b \u03b3\u2217 j , the proposed conditions give p = o{n1/5 \u2227(q2/n)1/3} up to a small order term. Remark 7. Similar to the discussion in Remark 6, the challenges arising from the unrestricted dependence between U\u2217and X also affect the derivation of the asymptotic distributions for the proposed estimators. If we consider the ideal case with (U\u2217)\u22baX = 0K\u00d7p, we can establish the asymptotic normality for all individual estimators under Assumptions 1\u20134 only and weaker scaling conditions. Specifically, when (U\u2217)\u22baX = 0K\u00d7p, the scaling condition becomes p\u221an(nq)3/\u03be(n\u22121p log qp+q\u22121 log n) \u21920 for deriving asymptotic normality of b \u03b2\u2217 j and b \u03b3\u2217 j , which is milder than that for (10) and (11). 23 \f5 Simulation Study In this section, we study the finite-sample performance of the proposed joint-likelihoodbased estimator. We focus on the logistic latent factor model in (1) with pij(y | wij) = exp(wijy)/{1 + exp(wij)}, where wij = (\u03b3\u2217 j )\u22baU \u2217 i + (\u03b2\u2217 j)\u22baXi. The logistic latent factor model is commonly used in the context of educational assessment and is also referred to as the item response theory model (Mellenbergh 1994, Hambleton & Swaminathan 2013). We apply the proposed method to estimate B\u2217and perform statistical inference on testing the null hypothesis \u03b2\u2217 js = 0. We start with presenting the data generating process. We set the number of subjects n = {300, 500, 1000, 1500, 2000}, the number of items q = {100, 300, 500}, the covariate dimension p = {5, 10, 30}, and the factor dimension K = 2, respectively. We jointly generate Xc i and U \u2217 i from N(0, \u03a3) where \u03a3ij = \u03c4 |i\u2212j| with \u03c4 \u2208{0, 0.2, 0.5, 0.7}. In addition, we set the loading matrix \u0393\u2217 [,k] = 1(K) k \u2297vk, where \u2297is the Kronecker product and vk is a (q/K)-dimensional vector with each entry generated independently and identically from Unif[0.5, 1.5]. For the covariate effects B\u2217, we set the intercept terms to equal \u03b2\u2217 j0 = 0. For the remaining entries in B\u2217, we consider the following two settings: (1) sparse setting: \u03b2\u2217 js = \u03c1 for s = 1, . . . , p and j = 5s\u22124, . . . , 5s and other \u03b2\u2217 js are set to zero; (2) dense setting: \u03b2\u2217 js = \u03c1 for s = 1, . . . , p and j = Rsq/5 + 1, . . . , (Rs + 1)q/5 with Rs = s \u22125\u230as/5\u230b, and other \u03b2\u2217 js are set to zero. Here, the signal strength is set as \u03c1 \u2208{0.3, 0.5}. Intuitively, in the sparse setting, we set 5 items to be biased for each covariate whereas in the dense setting, 20% of items are biased items for each covariate. For better empirical stability, after reaching convergence in the proposed alternating maximization algorithm and transforming the obtained MLEs into ones that satisfy Conditions 1\u20132, we repeat another round of maximization and transformation. We take the significance level at 5% and calculate the averaged type I error based on all the entries \u03b2\u2217 js = 0 and the averaged power for all non-zero entries, over 100 replications. The averaged hypothesis testing results are presented in Figures 3\u20136 for p = 5 and p = 30, across different 24 \fsettings. Additional numerical results for p = 10 are presented in the Supplementary Materials. 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 5, q = 100, rho = 0.3 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 5, q = 100, rho = 0.5 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 5, q = 300, rho = 0.3 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 5, q = 300, rho = 0.5 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 5, q = 500, rho = 0.3 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 5, q = 500, rho = 0.5 Figure 3: Powers and type I errors under sparse setting at p = 5. Red Circles ( ) denote correlation parameter \u03c4 = 0. Green triangles ( ) represent the case \u03c4 = 0.2. Blue squares ( ) indicate \u03c4 = 0.5. Purple crosses ( ) represent the \u03c4 = 0.7. 25 \f0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 30, q = 100, rho = 0.3 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 30, q = 100, rho = 0.5 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 30, q = 300, rho = 0.3 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 30, q = 300, rho = 0.5 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 30, q = 500, rho = 0.3 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 30, q = 500, rho = 0.5 Figure 4: Powers and type I errors under sparse setting at p = 30. Red Circles ( ) denote correlation parameter \u03c4 = 0. Green triangles ( ) represent the case \u03c4 = 0.2. Blue squares ( ) indicate \u03c4 = 0.5. Purple crosses ( ) represent the \u03c4 = 0.7. 26 \f0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 5, q = 100, rho = 0.3 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 5, q = 100, rho = 0.5 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 5, q = 300, rho = 0.3 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 5, q = 300, rho = 0.5 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 5, q = 500, rho = 0.3 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 5, q = 500, rho = 0.5 Figure 5: Powers and type I errors under dense setting at p = 5. Red Circles ( ) denote correlation parameter \u03c4 = 0. Green triangles ( ) represent the case \u03c4 = 0.2. Blue squares ( ) indicate \u03c4 = 0.5. Purple crosses ( ) represent the \u03c4 = 0.7. 27 \f0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 30, q = 100, rho = 0.3 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 30, q = 100, rho = 0.5 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 30, q = 300, rho = 0.3 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 30, q = 300, rho = 0.5 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 30, q = 500, rho = 0.3 0.00 0.20 0.40 0.60 0.80 1.00 0.05 300 500 1000 1500 2000 n Power/Type I Errors p = 30, q = 500, rho = 0.5 Figure 6: Powers and type I errors under dense setting at p = 30. Red Circles ( ) denote correlation parameter \u03c4 = 0. Green triangles ( ) represent the case \u03c4 = 0.2. Blue squares ( ) indicate \u03c4 = 0.5. Purple crosses ( ) represent the \u03c4 = 0.7. 28 \fFrom Figures 3\u20136, we observe that the type I errors are well controlled at the significance level 5%, which is consistent with the asymptotic properties of b B\u2217in Theorem 2. Moreover, the power increases to one as the sample size n increases across all of the settings we consider. Comparing the left panel (\u03c1 = 0.3) to the right panel (\u03c1 = 0.5) in Figures 3\u20136, we see that the power increases as we increase the signal strength \u03c1. Comparing the plots in Figures 3\u20134 to the corresponding plots in Figures 5\u20136, we see that the powers under the sparse setting (Figures 3\u20134) are generally higher than that of the dense setting (Figures 5\u20136). Nonetheless, our proposed method is generally stable under both sparse and dense settings. In addition, we observe similar results when we increase the covariate dimension p from p = 5 (Figures 3 and 5) to p = 30 (Figures 4 and 6). We refer the reader to the Supplementary Materials for additional numerical results for p = 10. Moreover, we observe similar results when we increase the test length q from q = 100 (top row) to q = 500 (bottom row) in Figures 3\u20136. In terms of the correlation between X and U\u2217, we observe that while the power converges to one as we increase the sample size, the power decreases as the correlation \u03c4 increases. 6 Data Application We apply our proposed method to analyze the Programme for International Student Assessment (PISA) 2018 data2. PISA is a worldwide testing program that compares the academic performances of 15-year-old students across many countries (OECD 2019). More than 600,000 students from 79 countries/economies, representing a population of 31 million 15year-olds, participated in this program. The PISA 2018 used the computer-based assessment mode and the assessment lasted two hours for each student, with test items mainly evaluating students\u2019 proficiency in mathematics, reading, and science domains. A total of 930 minutes of test items were used and each student took different combinations of the test items. In addition to the assessment questions, background questionnaires were provided to collect students\u2019 information. 2The data can be downloaded from: https://www.oecd.org/pisa/data/2018database/ 29 \fIn this study, we focus on PISA 2018 data from Taipei. The observed responses are binary, indicating whether students\u2019 responses to the test items are correct, and we use the popular item response theory model with the logit link (i.e., logistic latent factor model; Reckase 2009). Due to the block design nature of the large-scale assessment, each student was only assigned to a subset of the test items, and for the Taipei data, 86% response matrix is unobserved. Note that this missingness can be considered as conditionally independent of the responses given the students\u2019 characteristics. Our proposed method and inference results naturally accommodate such missing data and can be directly applied. Specifically, to accommodate the incomplete responses, we can modify the joint log-likelihood function in (2) into Lobs(Y | \u0393, U, B, X) = Pn i=1 P j\u2208Qi lij(\u03b3\u22ba j Ui + \u03b2\u22ba j Xi), where Qi defines the set of questions to which the responses from student i are observed. In this study, we include gender and 8 variables for school strata as covariates (p\u2217= 9). These variables record whether the school is public, in an urban place, etc. After data preprocessing, we have n = 6063 students and q = 194 questions. Following the existing literature (Reckase 2009, Millsap 2012), we take K = 3 to interpret the three latent abilities measured by the math, reading, and science questions. We apply the proposed method to estimate the effects of gender and school strata variables on students\u2019 responses. We obtain the estimators of the gender effect for each PISA question and construct the corresponding 95% confidence intervals. The constructed 95% confidence intervals for the gender coefficients are presented in Figure 7. There are 10 questions highlighted in red as their estimated gender effect is statistically significant after the Bonferroni correction. Among the reading items, there is only one significant item and the corresponding confidence interval is below zero, indicating that this question is biased towards female test-takers, conditioning on the students\u2019 latent abilities. Most of the confidence intervals corresponding to the biased items in the math and science sections are above zero, indicating that these questions are biased towards male test-takers. In social science research, it is documented that female students typically score better than male students 30 \fduring reading tests, while male students often outperform female students during math and science tests (Quinn & Cooc 2015, Balart & Oosterveen 2019). Our results indicate that there may exist potential measurement biases resulting in such an observed gender gap in educational testing. Our proposed method offers a useful tool to identify such biased test items, thereby contributing to enhancing testing fairness by providing practitioners with valuable information for item calibration. Math Reading Science \u22126 \u22123 0 3 6 0 50 100 150 200 PISA Questions for TAP Gender Effect Estimator Figure 7: Confidence intervals for the effect of gender covariate on each PISA question using Taipei data. Red intervals correspond to confidence intervals for questions with significant gender bias after Bonferroni correction. (For illustration purposes, we omit the confidence intervals with the upper bounds exceeding 6 and the lower bounds below -6 in this figure). To further illustrate the estimation results, Table 1 lists the p-values for testing the gender effect for each of the identified 10 significant questions, along with the proportions of female and male test-takers who answered each question correctly. We can see that the signs of the estimated gender effect by our proposed method align with the disparities in the reported proportions between females and males. For example, the estimated gender effect corresponding to the item \u201cCM496Q01S Cash Withdrawal\u201d is positive with a p-value 31 \fItem code Item Title Female (%) Male (%) p-value Mathematics CM496Q01S Cash Withdrawal 51.29 58.44 2.77\u00d710\u22127 (+) CM800Q01S Computer Games 96.63 93.61 < 1 \u00d7 10\u22128 (\u2212) Reading CR466Q06S Work Right 91.91 86.02 1.95\u00d710\u22125 (\u2212) Science CS608Q01S Ammonoids 57.68 68.15 4.65\u00d710\u22125 (+) CS643Q01S Comparing Light Bulbs 68.57 73.41 1.08\u00d710\u22125 (+) CS643Q02S Comparing Light Bulbs2 63.00 57.50 4.64\u00d710\u22124 (\u2212) CS657Q03S Invasive Species 46.00 54.36 8.47\u00d710\u22125 (+) CS527Q04S Extinction of Dinosours3 36.19 50.18 8.13\u00d710\u22125 (+) CS648Q02S Habitable Zone 41.69 45.19 1.34\u00d710\u22124 (+) CS607Q01S Birds and Caterpillars 88.14 91.47 1.99\u00d710\u22124 (+) Table 1: Proportion of full credit in females and males to significant items of PISA2018 in Taipei. (+) and (\u2212) denote the items with positively and negatively estimated gender effects, respectively. of 2.77 \u00d7 10\u22127, implying that this question is statistically significantly biased towards male test-takers. This is consistent with the observation that in Table 1, 58.44% of male students correctly answered this question, which exceeds the proportion of females, 51.29%. Besides gender effects, we estimate the effects of school strata on the students\u2019 response and present the point and interval estimation results in the left panel of Figure 8. All the detected biased questions are from math and science sections, with 6 questions for significant effects of whether attending public school and 5 questions for whether residing in rural areas. To further investigate the importance of controlling for the latent ability factors, we compare results from our proposed method with the latent factors, to the results from directly regressing responses on covariates without latent factors. From the right panel of Figure 8, we can see that without conditioning on the latent factors, there are excessive items detected for the covariate of whether the school is public or private. On the other hand, there are no biased items detected if we only apply generalized linear regression to estimate the effect of the covariate of whether the school is in rural areas. 32 \fMath Reading Science \u22124 0 4 0 50 100 150 200 PISA Questions for TAP Public School Effect Estimator Public Math Reading Science \u22122 \u22121 0 1 2 0 50 100 150 200 PISA Questions for TAP Public School Effect Estimator Public \u2212 without latent variable Math Reading Science \u22124 0 4 0 50 100 150 200 PISA Questions for TAP Rural Region Effect Estimator Rural Math Reading Science \u22122 \u22121 0 1 2 0 50 100 150 200 PISA Questions for TAP Rural Region Effect Estimator Rural \u2212 without latent variable Figure 8: Confidence intervals for the effect of school stratum covariate on each PISA question. Red intervals correspond to confidence intervals for questions with significant school stratum bias after Bonferroni correction. 7 Discussion In this work, we study the covariate-adjusted generalized factor model that has wide interdisciplinary applications such as educational assessments and psychological measurements. In particular, new identifiability issues arise due to the incorporation of covariates in the model setup. To address the issues and identify the model parameters, we propose novel and interpretable conditions, crucial for developing the estimation approach and inference results. With model identifiability guaranteed, we propose a computationally efficient jointlikelihood-based estimation method for model parameters. Theoretically, we obtain the estimation consistency and asymptotic normality for not only the covariate effects but also latent factors and factor loadings. 33 \fThere are several future directions motivated by the proposed method. In this manuscript, we focus on the case in which p grows at a slower rate than the number of subjects n and the number of items q, a common setting in educational assessments. It is interesting to further develop estimation and inference results under the high-dimensional setting in which p is larger than n and q. Moreover, in this manuscript, we assume that the dimension of the latent factors K is fixed and known. One possible generalization is to allow K to grow with n and q. Intuitively, an increasing latent dimension K makes the identifiability and inference issues more challenging due to the increasing degree of freedom of the transformation matrix. With the theoretical results in this work, another interesting related problem is to further develop simultaneous inference on group-wise covariate coefficients, which we leave for future investigation.",
+    "additional_info": [
+        {
+            "url": "http://arxiv.org/abs/2404.12893v1",
+            "title": "The Power of Words: Generating PowerShell Attacks from Natural Language",
+            "abstract": "As the Windows OS stands out as one of the most targeted systems, the\nPowerShell language has become a key tool for malicious actors and\ncybersecurity professionals (e.g., for penetration testing). This work explores\nan uncharted domain in AI code generation by automatically generating offensive\nPowerShell code from natural language descriptions using Neural Machine\nTranslation (NMT). For training and evaluation purposes, we propose two novel\ndatasets with PowerShell code samples, one with manually curated descriptions\nin natural language and another code-only dataset for reinforcing the training.\nWe present an extensive evaluation of state-of-the-art NMT models and analyze\nthe generated code both statically and dynamically. Results indicate that\ntuning NMT using our dataset is effective at generating offensive PowerShell\ncode. Comparative analysis against the most widely used LLM service ChatGPT\nreveals the specialized strengths of our fine-tuned models.",
+            "authors": "Pietro Liguori, Christian Marescalco, Roberto Natella, Vittorio Orbinato, Luciano Pianese",
+            "published": "2024-04-19",
+            "updated": "2024-04-19",
+            "primary_cat": "cs.CR",
+            "cats": [
+                "cs.CR",
+                "cs.SE"
+            ],
+            "label": "Original Paper",
+            "paper_cat": "LLM Fairness",
+            "gt": "The Power of Words: Generating PowerShell Attacks from Natural Language",
+            "main_content": "Introduction Offensive security practices, such as red teaming and adversary emulation, play a crucial role by helping us to understand how attackers take advantage of vulnerabilities and how to mitigate attacks [1, 2]. In these attacks, cybersecurity professionals emulate malicious post-exploitation actions, such as credential stealing, lateral movement across accounts and machines, data obfuscation and exfiltration, and more [3]. As Windows stands out as one of the most targeted OS [4], the PowerShell language has become a key tool for both malicious actors and cybersecurity professionals. This language is widely used to perform attacks since it can perform complex actions, such as establishing connections and accessing OS services and APIs without the need to deliver a malicious binary executable or payload on the target machine (e.g., \u201cfileless\u201d malware), making them harder to detect [5\u20138]. Unfortunately, writing offensive code demands a high degree of expertise and effort, restricting the adoption of offensive security practices. Therefore, the rise of automatic AI code generators represents an appealing solution to unlock these practices to a broader spectrum of users [9]. AI code generators leverage ML models for Neural Machine Translation (NMT) to produce (offensive) code starting from inputs in Natural Language (NL), e.g., in the English language. The usage of NMT models is widespread across diverse software engineering tasks [10], yet their application in security-related scenarios is infrequent and not widely explored. This gap stems primarily from the lack of suitable corpora for training and evaluating code generators. The shortage of corpora for offensive code generation is an evident limitation: existing benchmarks [11\u201313] are derived from programming competitions and software interview questions (e.g., about algorithms and mathematics), or they focus on programs and languages that are not related to security (e.g., web applications in Python). Only a few security-oriented datasets are publicly available, targeting shellcodes in low-level programming languages [14]. As a result, there is a significant gap in the literature on offensive PowerShell code generation. This work presents an assessment of AI code generators for PowerShell offensive code, a novel application of NMT. Given that generative models are predominantly trained on mainstream programming languages like Python and Java, we investigate strategies to repurpose these models for the PowerShell domain. To this aim, we adopt a combination of unlabeled and labeled datasets to train and evaluate models. Specifically, we first use a large collection of unlabeled (i.e., code only) samples of general-purpose PowerShell from various online repositories to pre-train ML models and refine their capabilities to comprehend and generate PowerShell code. Then, we build from scratch a manually annotated labeled dataset consisting of PowerShell code samples specifically crafted for security applications, which we pair with curated NL descriptions in English. We use this dataset to fine-tune three state-of-the-art NMT models (CodeT5+ [15], CodeGPT [16], and CodeGen [17]) to generate offensive PowerShell code. The dataset also serves as a ground truth for 1 arXiv:2404.12893v1  [cs.CR]  19 Apr 2024 \fthe evaluation. We publicly share code, models 1 and datasets as open data2 to encourage further experimentation on this topic. To perform our experiments, we formulate four key research questions (RQs) aimed at evaluating the models\u2019 capabilities and the impact of the training strategies, performing static and execution analysis to assess the generated code, and comparing privately fine-tuned models with ChatGPT, the most widely used LLM service from OpenAI [18]. Table 1 summarizes the key findings of our analysis. To the best of our knowledge, this is the first work on the automatic generation of offensive PowerShell code from NL descriptions. In the following, Section 2 discusses related work; Section 3 describes the research study; Section 4 shows the experimental results; Section 5 discusses the threats to validity; Section 6 discusses the ethical considerations; Section 7 concludes the paper. 2 Related Work This work focuses on offensive code generation, involving machine translation techniques applied to the security domain for PowerShell code generation. Thus, we reviewed related literature in these areas. ML for security-related PowerShell. Li et al. [19] designed a subtree-based de-obfuscation method and a semantic-aware PowerShell attack detection system. This work also demonstrates how the presented de-obfuscation method improves the performance of detection systems such as Windows Defender and Virus-Total. PowerDP [20] is a solution that aims to automatically identify malicious PowerShell commands through character distribution features and obfuscation multi-label classification also proposing a de-obfuscator method for recovering obfuscated commands. Even ML-based methodologies have arisen for detection purposes, as shown by Hendler et al. [21], who proposed several ML-based detectors demonstrating their effectiveness on malicious scripts. The authors also devised another solution [22] to achieve the same objective by retrieving information from Microsoft\u2019s AMSI interface. Mimura and Tajiri [23] presented a lighter methodology, restricting detection only to word embeddings. Mezawa et al. [24] proposed an evaluation methodology for ML-based detectors based on a word-level machine learning model. Given the effectiveness of Abstract Syntax Trees (ASTs) in detecting obfuscated PowerShell scripts, Rusak et al. [25] proposed a hybrid approach that combines ASTs and deep learning to enhance detection methods for high-level obfuscation PowerShell malicious programs. We remark that research of ML for PowerShell focuses on defensive uses (i.e., detecting and de-obfuscating attacks), but none of these studies analyzed the offensive uses of ML (i.e., generating attacks), which are also 1HuggingFace repo 2GitHub repo Analysis Main Findings Capability Assessment \u2022 Models without fine-tuning (zero-shot learning) showed a limited ability to generate PowerShell code, often defaulting to Python syntax or incorrect PowerShell code. \u2022 The fine-tuning phase significantly enhanced the models\u2019 ability to generate syntactically correct and semantically relevant PowerShell code. Among the models, CodeT5+ and CodeGPT demonstrated notable improvements in generating offensive PowerShell code. \u2022 Pre-training on a large PowerShell corpus had a varying impact on different models. While pre-training generally improved CodeT5+ and CodeGPT, especially with a limited number of epochs for fine-tuning, CodeGen did not consistently benefit from pre-training. Static and Execution Analysis \u2022 All models achieved high syntax accuracy, indicating their strong capability to generate syntactically correct code. However, a significant number of warnings were identified, suggesting potential issues or suboptimal coding practices. \u2022 The execution analysis showed that, despite textual differences between the ground truth and the generated code, the models are still able to generate offensive PowerShell code closely aligned with the intended malicious activities, in terms of events occurring in the system (e.g., on the filesystem, network, registry). Comparison with public AI model \u2022 Our fine-tuned models outperform ChatGPT across all the metrics, showing that specializing the models on our fine-tuning dataset provides an advantage in the offensive PowerShell code generation task. Table 1: Main findings. relevant for red teaming and adversary emulation purposes, and which are in the scope of this paper. Offensive Code Generation. Research on AI code generators for offensive security is still at an early stage. Gupta et al. [26] presented an outlook of the possibilities opened by ChatGPT for generating various types of cyber attacks, such as social engineering, phishing attacks, and malware creation. For each attack scenario, the paper shows qualitative examples of prompts submitted to ChatGPT, and the attack payloads generated as a result, including some snippets of PowerShell code. Similarly, Charan et al. [27] presented qualitative examples with ChatGPT and Google BARD to generate malicious 2 \fscripts (mainly in Python, Bash, and PowerShell) for the top 10 prevalent MITRE Techniques of 2022, showing the potential of these AI models for security applications. However, none of these studies systematically analyzed AI code generators, lacking in several aspects: (i) the evaluation was limited to a few examples, while systematic evaluation requires much larger datasets; (ii) the study lacked a ground truth for evaluating the correctness of generated code; (iii) they did not yet explore the potential of fine-tuning ML models for securityrelated code generation. The few studies in this direction focused on generating exploits in low-level languages (e.g., to attack memory management vulnerabilities). However, exploitation is only a limited part of the cyber kill chain, overlooking several more types of malicious code. Among these studies, Liguori et al. [28] proposed a dataset and approach for training and evaluating AI code generators for code security, by generating shellcodes in Assembly language. EVIL [29] automatically generates exploits for conducting code injection attacks via NMT by targeting both the generation of shellcodes in Assembly language and related Python code for encoding and obfuscating the shellcodes. DualSC [30] formalizes the automatic generation and summarization of shellcodes via a \"Shallow\" Transformer inspired by the T5 model and dual learning using the corpus provided by Liguori et al. [28]. ExploitGen [31] is an approach for generating exploit code in Python and Assembly based on the CodeBERT model. Differently from these studies, we presented a dedicated model for generating offensive PowerShell code, covering the entire cyber kill chain (e.g., including credential stealing, lateral movement, data exfiltration, and more tactics from the MITRE ATT&CK taxonomy). Moreover, we systematically analyzed the quality of generated PowerShell code by introducing a manually curated dataset to serve as a ground truth and evaluating the code statically and dynamically. 3 Research Study The main objective of our research study is to understand whether NMT models can translate NL descriptions into code that accurately replicates the complexities of cyber attacks in PowerShell. This aspect is crucial as it explores the models\u2019 understanding of the unique syntax and semantics of this programming language. Figure 1 provides an overview of this research study. We analyze various deep learning strategies to accurately generate code and introduce datasets to train and evaluate them. We study several state-of-the-art NMT models and introduce various approaches to evaluating the generated code, including the similarity of the generated code to ground truth and static and dynamic analysis of the code. To help NMT models in the novel and ambitious task of generating PowerShell code from NL, we adopt a two-step process consisting of pre-training and fine-tuning. The pretraining phase aims to tailor NMT models (already pre-trained on other programming languages) in the generation of PowerShell code. Armed with the pre-trained models, we proceed to the fine-tuning phase. This iterative process refines the models\u2019 capabilities, enabling them to generate offensive PowerShell code from NL descriptions. The main problem in using NMT models is to have a sufficient set of data and to use them effectively to train the models themselves. Recognizing the lack of suitable datasets for offensive PowerShell code generation, in this study, we collect a large set of PowerShell programs used for penetration testing and adversary emulation. In addition to the code, we create descriptions of these programs in English to allow the model to translate English into PowerShell code. This dataset was created manually to verify that the programs were related to security and to ensure that the English language descriptions were complete and consistent with the code. The dataset is labeled since each sample includes both the text to translate into code and the code expected to be produced by the model (ground truth). The creation of labeled datasets is inevitably limited by the availability of PowerShell security programs and the need to manually create English language descriptions for each program. To increase the amount of training data, in this study, we investigate an additional strategy, fully automated, to build an extended dataset of PowerShell programs, collecting PowerShell programs and the related text from the web (for example, comments in the code or description accompanying the code). As the collection is fully automated, this second dataset is non-labeled. The dataset includes programs not strictly related to security but includes, in general, PowerShell code used for various purposes. This dataset still contributes to the ability to generate security code since it allows the model to learn from further examples how to generate syntactically valid PowerShell code and to correlate the PowerShell code with the English language. We use this dataset to pre-train the NMT models, carrying out additional unsupervised training rounds. Table 2 reports the statistics of both datasets, in terms of size, unique number of tokens, and average number of tokens for NL descriptions (only for fine-tuning data) and code. Finally, we evaluate the models as follows: \u2022 Capability Assessment: We compare the textual similarity of the code generated by the models with a groundtruth reference through automatic metrics. These metrics are an appealing solution to estimate the generated code since they are easy to tune and time-saving, hence overcoming the limit of human evaluation, which poses practical challenges for large-scale assessments. \u2022 Static analysis: We assess the generated code to ensure that it adheres to PowerShell programming conventions and does not contain syntax errors. \u2022 Execution analysis: We evaluate the capability of the 3 \fData Collection Pre-training Fine-tuning Stockpile Data Collection Atomic Red Team Online Empire GitHub Pre-training  Dataset Fine-tuning  Dataset Pre-trained Models PowerShell Code Capability  Assessment NL Intents Output  Similarity AI-based Code Generation Syntactic Evaluation Execution  Evaluation Static  Analysis Execution  Analysis Legend Code Generation Task \u2013 \u222e4.1, 4.2 Fine-tuning data \u2013 \u222e3.2 Pre-training data \u2013 \u222e3.1 Static Analysis \u2013 \u222e4.3 Execution Analysis\u2013 \u222e4.4 CodeT5+ CodeGPT CodeGen Figure 1: Overview of our research study. generated offensive PowerShell code in executing malicious actions, replicating the behavior of the ground truth commands. In the following of this section, we detail the pre-training (\u00a7 3.1) and the fine-tuning data (\u00a7 3.2), and the code generation task (\u00a7 3.3). 3.1 Pre-training data (unlabeled) Pre-training involves training the model on a large corpus of text data to learn general language representations before fine-tuning it for specific downstream tasks [32]. In other words, the parameters obtained from this step serve as a starting point for the later supervised training. Unsupervised or self-supervised pre-training is particularly attractive in the NMT context since large unlabeled data is available on the Internet. In this work, we leverage domain-adaptive pre-training (DAPT) [33]: given an NMT model pre-trained on massive, heterogeneous corpora, we perform additional rounds of unsupervised training with domain-specific data. Specifically, we leverage general-purpose PowerShell code for pre-training. The pre-training dataset aims to provide a valuable resource to enable the models\u2019 understanding of general-purpose PowerShell code. This dataset encompasses \u223c90k samples extracted through the GitHub API. Specifically, we queried all the repositories containing PowerShell code from the last decade (2013-2023) to encompass a broad spectrum of PowerShell code, then parsed the extracted data to remove unnecessary information, such as duplicates (inside the same repository), and logging and echo commands. In addition, we filtered out all the PowerShell commands with sizes greater than 1024, ensuring the dataset maintains a balanced representation of code complexities. This collection encompasses a diverse array of PowerShell scripts, spanning various application domains such as system administration, automation, and network management. Including a wide range of scripts reflects the versatility of PowerShell as a scripting language and provides models with exposure to the diverse ways PowerShell is used across different use cases. The pre-training process depends on the model architecture. For decoder-only models, i.e., CodeGPT and CodeGen, we chose Causal Language Modeling (CLM), also referred to as Language Modeling, as the pre-training objective. CLM has been extensively used as a pre-training task for transformerbased decoder-only models [34], such as in the GPT series [35\u201337]. CLM refers to language models that predict the next token or sequence of tokens in a sentence in a causal or autoregressive manner, where the prediction for each token depends only on the preceding tokens. By using masking, the model only attends to the left context in a unidirec4 \fStatistic Pre-training Dataset Fine-tuning Dataset Dataset size 89,814 1,127 Unique Intents 1,077 Unique Commands 79,410 1,121 Unique tokens (Intents) 2,273 Unique tokens (Commands) 85,342 17,463 Avg. tokens per Intent 15.97 Avg. tokens per Command 12.71 15.49 Table 2: Statistics of the pre-training and fine-tuning datasets. The pre-training dataset does not contain NL descriptions (intents). tional manner, ensuring that it cannot see \"into the future\". In the probabilistic framework, starting from the text sequence x = (x1,x2,x3,...,xT), where x is the original sentence and xt (t = 1,2,...,T) is the t-th token, and T is the sequence length, an autoregressive model factorizes the likelihood of the input text sequence as p(x) = \u220fT t=1 p(xt | x<t), where p is the likelihood of the input text sequence [38]. Finally, models are evaluated by token-level accuracy. For CodeT5+, the pre-training objective is Masked Language Modeling (MLM), as recent works show its effectiveness in code understanding tasks [39]. MLM refers to the prediction of missing tokens in a sentence based on the context provided by the surrounding tokens. Unlike the left-to-right language model pre-training, MLM considers both the left and right context. The approach is inspired by BERT [40], where 15% of the tokens in the encoder inputs are randomly replaced with sentinel token [MASK], and the decoder is tasked with recovering these tokens to reconstruct the complete snippet. The model is evaluated by token level accuracy only on the masked-out tokens. 3.2 Fine-tuning data (labeled) The overarching purpose of this dataset is to serve as a comprehensive resource for training models in the translation of NL intents, i.e., descriptions of code snippets, into executable security-oriented PowerShell commands. Specifically, we focus on offensive PowerShell code, a key resource for cybersecurity exercises since Microsoft Windows represents the most targeted OS. By encompassing a wide array of sources, the dataset aims to expose models to the intricacies of realworld cybersecurity scenarios, enabling them to understand and generate PowerShell commands that align with those typical of cybersecurity operations. This holistic approach strives to ensure that models trained on this dataset are well-equipped to handle the complexities of real-world tasks and contribute meaningfully to offensive code generation, specifically PowerShell commands. The dataset, consisting of 1,127 samples of PowerShell commands, is meticulously curated from the following sources: \u2022 Atomic Red Team [41]: renowned for its library of tests mapped to the MITRE ATT&CK framework3 [42], serves the purpose of replicating real-world adversarial tactics, techniques, and procedures (TTPs). This inclusion provides the dataset with a foundation rooted in a standardized and widely accepted framework, ensuring that the PowerShell commands align with recognized cybersecurity methodologies. \u2022 Stockpile [43]: is a plugin for the CALDERA cybersecurity framework [1,44] developed by MITRE and introduces a layer of sophistication by incorporating structured data integral for adversary emulation. Therefore, the dataset does not encompass raw PowerShell commands only but also captures the contextual information and relationships between commands within the broader context of adversarial scenarios. \u2022 Empire [45]: a post-exploitation and adversary emulation framework integrated with MITRE ATT&CK, provides PowerShell commands representative of advanced malicious techniques, further enriching the dataset with nuanced and intricate scenarios. \u2022 Online sources: we manually verified and selected additional offensive samples from several security-related online sources. We gathered samples from HackTricks [46], Red Team Recipe [47], and Infosec Matter [48], community-driven cybersecurity wikis about ethical hacking, penetration testing, and information security. By including diverse examples specific to the offensive PowerShell dataset, the model acquires a more profound understanding of the conventions and best practices unique to PowerShell security commands. We manually curated the dataset to cover the highest number of tactics in the MITRE ATT&CK framework. In particular, the dataset covers 12 out of 14 tactics from the MITRE ATT&CK framework, the de facto standard for adversarial techniques representation, with varying numbers of techniques and sub-techniques per tactic. Figure 2 illustrates the number of entries for each ATT&CK tactic. Each entry in the dataset is annotated with an NL description extracted from the respective source. We manually annotated every sample that did not come with a predefined description. Moreover, we enriched all those descriptions that did not provide enough information about the specific PowerShell command. For instance, in the case of Atomic Red Team, the PowerShell commands represent implementations of the techniques in the ATT&CK framework. Consequently, these commands are 3The ATT&CK framework is a comprehensive knowledge base of the tactics, techniques, and procedures (TTPs) that adversaries leverage during cyberattacks, developed by MITRE. 5 \f32 38 163 430 205 54 10 12 4 96 42 37 5 0 100 200 300 400 500 Collection Command and Control Credential Access Defense Evasion Discovery Execution Exfiltration Impact Initial Access Lateral Movement Persistence Privilege Escalation Reconnaissance Number of dataset entries MITRE ATT&CK Tactics Figure 2: Mapping of fine-tuning dataset samples on the MITRE ATT&CK tactics. often labeled with the technique name, which provides informative content about the technique itself rather than what the command does. To better understand how programmers and security experts describe PowerShell scripts and how to deal with ambiguities in natural language, we referred to popular books and manuals [49\u201351]. Finally, we notice that the size of our dataset is in line with other state-of-the-art corpora used to fine-tune ML models. In fact, in state-of-the-art code generation, the datasets for fine-tuning are relatively limited, in the order of one thousand samples [52]. 3.3 Code Generation Task To ensure the robustness of our study, we adopt the following state-of-the-art NMT models: \u2022 CodeT5+ [15] is a new family of Transformer models pre-trained with a diverse set of pretraining tasks to learn rich representations from both unimodal code data and bimodal code-text data. We utilize the variant with model size 220M, trained from scratch following T5\u2019s architecture [53]. It has an encoder-decoder architecture with 12 decoder layers, each with 12 attention heads and hidden layer dimension of 768, and 512 for the size of position embeddings. We set the learning rate \u03b1 = 0.00005, batch size = 16, and beam size = 10. \u2022 CodeGPT [16], a Transformer-based language model pre-trained on millions of Python functions and Java methods. The model architecture consists of 12 layers of Transformer decoders. We followed previous work for the implementation [54]. \u2022 CodeGen [17], an autoregressive language model for program synthesis with an architecture that follows a standard transformer decoder with left-to-right causal masking. The family of CodeGen models is trained in various sizes, including 350M, 2.7B, 6.1B, and 16.1B, and utilizes various datasets. Specifically, we leverage CodeGen-Multi, initialized from CodeGen-NL and further pre-trained on BigQuery [17], a large-scale dataset of multiple programming languages from GitHub repositories, which consists of 119.2B tokens and includes C, C++, Go, Java, JavaScript, and Python. In our experiments, we randomly split the fine-tuning dataset into training (the set of examples used to fit the parameters), validation (the set used to tune the hyperparameters of the models), and test (the set used for the evaluation of the models) sets using a typical 80%/10%/10% ratio. To assess the performance of the models in generating offensive PowerShell code from NL descriptions, we used output similarity metrics, which compare the generated code with the code from the ground truth. This type of metrics is widely used to assess the performance of AI generators in many code generation tasks [55], including the generation of code for security contexts [28\u201331,56]. The metrics are: \u2022 Bilingual Evaluation Understudy (BLEU) score [57]. It measures the degree of n-gram overlapping between the string of each code snippet produced by the model and the reference, for values of n usually ranging between 1 and 4 [58, 59]. We implemented BLEU-4 score (i.e., with n = 4) computation employing the bleu_score module contained in the open-source Natural Language Toolkit (NLTK) Python suite [60]. \u2022 Edit Distance (ED). It measures the edit distance between two strings, i.e., the minimum number of operations on single characters required to make each code snippet produced by the model equal to the reference. For the edit distance, we adopted the Python library pylcs [61]. \u2022 METEOR [62]. It measures the alignment between each code snippet produced by the model and the reference. The alignment is defined as a mapping between unigrams (i.e., 1-gram), such that every unigram in each string maps to zero or one unigram in the other string and no unigrams in the same string. To calculate the METEOR metric, we relied on the Python library evaluate by HuggingFace [63]. \u2022 ROUGE-L. It is a metric based on the longest common subsequence (LCS) between the model output and the reference, i.e., the longest sequence of words (not necessarily consecutive, but still in order) shared between both. We computed the ROUGE-L metric using the Python package rouge [64]. All metrics range between 0 and 1, with higher scores corresponding to a better quality of the generated code. To evaluate the generated PowerShell code, we also introduce additional evaluation metrics based on static and dynamic analysis that are specific to our context. These metrics will be introduced in the following sections. 6 \f3.4 Research Questions We designed this research study to answer the following research questions (RQs): \u25b7RQ1: To what extent can NMT models effectively generate offensive PowerShell code for security applications from NL descriptions? RQ1 aims to establish a preliminary assessment of NMT models in generating PowerShell code for offensive security applications. This investigation seeks to shed light on the models\u2019 efficacy in translating NL descriptions into offensive code. \u25b7RQ2: What is the influence of the training strategies on NMT models\u2019 performance in offensive PowerShell code generation? RQ2 focuses on the impact of pre-training and fine-tuning on the quality of generated code. We analyze the influence of these training strategies by considering different configurations of the NMT models and their impact on their performance. \u25b7RQ3: How good is the generated code in terms of code quality and dynamic behavior? RQ3 aims to evaluate the generated PowerShell code in a deeper way than output similarity metrics, in terms of syntactic correctness and capability of executing malicious actions realistically, through behavioral comparison with the ground truth. \u25b7RQ4: How do fine-tuned NMT models, leveraging securityoriented training data, compared to a publicly available, closed-source model? RQ4 introduces a comparative analysis, evaluating the performance of the fine-tuned models against a publicly available general-purpose language model, specifically ChatGPT 3.5. This investigation strives to evaluate whether specialization on security-focused data provides an advantage in the offensive PowerShell code generation domain. 4 Experimental Results This section presents an extensive evaluation of NMT models (CodeT5+, CodeGPT, and CodeGen) on the generation of offensive PowerShell code. First, we assess the models\u2019 capability of generating PowerShell code in their original configuration (\u00a7 4.1) without further training. Then, we evaluate the impact of different training strategies, i.e., domain-adaptive pre-training and fine-tuning, on the performance of such models (\u00a7 4.2). To provide further insight into the PowerShell code generation, we analyze the quality of the generated code in terms of syntactic correctness (\u00a7 4.3) and dynamic behavior (\u00a7 4.4), i.e., its ability to replicate the behavior of the ground truth code. Finally, we compare the fine-tuned models with a public AI model (ChatGPT) for all the previous analyses (\u00a7 4.5) to benchmark their performance against a publicly available, closed-source model. Model Pretraining BLEU-4 (%) ED (%) METEOR (%) ROUGEL (%) CodeT5+ \u2717 0.04 8.87 4.69 1.08 \u2713 0.01 6.96 1.86 2.68 CodeGPT \u2717 0.23 12.31 4.08 1.19 \u2713 0.28 15.67 2.55 3.41 CodeGen \u2717 0.06 7.58 2.88 0.21 \u2713 0.00 0.43 0.09 0.00 Table 3: Performance of models with and without pre-training on zero-shot. 4.1 Zero-shot Learning To establish a baseline for the evaluation, we initially used the NMT models in their original configuration, asking them to generate PowerShell code. This is a zero-shot learning task, where an NMT model is applied for a different scenario than the one for which it was trained. In this way, we evaluate the current gap of existing models in generating PowerShell code. Table 3 shows the results of this analysis. In this task, the models are tested without any gradient updates, relying only on the intent provided by the test set for inference [36,37]. The non-pre-trained versions of the models tend to generate Python code, but their performance is generally low for the downstream task of generating offensive PowerShell code. Pre-training the models with general-purpose PowerShell code slightly improves the accuracy but is still not high. Among the pre-trained versions, CodeGPT is the only one that provides output close to valid PowerShell code, although it does not align well with the expected code indicated by the intent in natural language. In summary, regardless of pre-training, all models demonstrate the need for fine-tuning on a tailored dataset for optimal performance in generating offensive PowerShell code. 4.2 Impact of Training Strategies The evaluation of CodeT5+, CodeGPT, and CodeGen involved a meticulously designed test plan. More precisely, the models underwent three distinct fine-tuning scenarios: 3 Epochs, 10 Epochs, and 30 Epochs. This deliberate choice allowed us to assess the impact of prolonged fine-tuning on the models\u2019 ability to generate PowerShell code for offensive security tasks. In each scenario, we considered two training configurations: one with pre-training and the other without. This test plan allowed us to systematically explore the models\u2019 capabilities under varying conditions, providing a comprehensive understanding of their strengths and limitations. Table 4 shows the results. In the 3 epochs setting, CodeT5+ exhibits low performance, regardless of pre-training, with a BLEU-4 score lower than 10%. In contrast, CodeGPT and CodeGen demonstrate notable performance even after a short fine-tuning period, 7 \fModel Epochs Pretrain. (%) BLEU-4 (%) ED (%) METEOR (%) ROUGEL (%) CodeT5+ 3 \u2717 4.22 35.11 28.83 22.26 \u2713 4.57 35.96 30.57 23.99 10 \u2717 12.64 46.72 44.76 37.65 \u2713 11.88 49.10 46.11 37.17 30 \u2717 17.40 50.92 47.61 39.05 \u2713 18.50 50.23 47.87 38.86 CodeGPT 3 \u2717 10.28 40.71 31.21 25.60 \u2713 12.80 42.54 35.14 30.35 10 \u2717 16.22 46.39 40.50 33.52 \u2713 17.93 49.88 45.12 37.12 30 \u2717 21.71 50.17 45.34 38.63 \u2713 19.94 49.20 45.45 38.06 CodeGen 3 \u2717 16.20 47.68 42.27 35.97 \u2713 14.75 45.88 39.86 34.69 10 \u2717 19.15 50.52 46.76 37.63 \u2713 19.04 48.45 43.25 35.25 30 \u2717 18.23 47.53 44.10 35.48 \u2713 18.53 48.67 44.14 35.45 Table 4: Performance of models with and without pre-training and different number of epochs. Best results for each metric are blue/bold. achieving a BLEU-4 score higher than 10% and an ED over 40%. Notably, after 3 epochs, CodeGen demonstrates superior performance compared to the other two models. In the 10 epochs experiment, CodeT5+ shows significant improvement, with BLEU-4 tripling to 12%. Moreover, ED, METEOR, and ROUGE-L experience a rise of 12-16%. CodeGPT also enhances its performance, surpassing CodeT5+ in terms of BLEU-4 score, although it faces challenges in achieving the same level of overall improvement. CodeGen remains ahead of the other models, even reaching an ED over 50%. For a more in-depth assessment of the models\u2019 adaptability, the training duration is extended to 30 epochs. CodeT5+ demonstrates superior performance over CodeGPT in ED, METEOR, and ROUGE-L metrics, while CodeGPT exhibits a higher BLEU-4 score surpassing 20%. Notably, both models achieve a high ED value of around 50%. CodeGen establishes its performance without further improvement compared to the 10 epochs versions. To provide an estimate of the goodness of the results, we compared the results of the models with the performance of the state-of-the-art (SOTA). Since the task of generating PowerShell using NMT models is a task never addressed before, we compared the results with recent work investigating the effectiveness of existing models in the generation of different languages from NL, specifically, Python code [65] and in shell language [66]. We found that the best performance is 21% for BLEU-4 and 38% for METEOR in the case of the Python language, and 25% for BLEU-4 and 44% for ED in the case of shell language. We notice that our results are in line with the ones of the SOTA. Even better, our best performance, represented by CodeT5+ without pre-training and 30 fine-tuning epochs, overcomes the SOTA over all the metrics. We also assessed the impact of varying the number of epochs on fine-tuning time, with distinct differences observed between 3, 10, and 30 epochs for each model. For both CodeT5+ and CodeGPT, fine-tuning over 3 epochs takes approximately 20 minutes, whereas CodeGen requires double that time (40 minutes). Extending to 10 epochs, CodeT5+ and CodeGPT need around 35 and 39 minutes, respectively, while CodeGen\u2019s training time increases to 90 minutes. For the 30epoch extension, CodeT5+ takes about 80 minutes, CodeGPT requires 110 minutes, and CodeGen extends its training time to 270 minutes. Finally, the comparison between the finetuning times of pre-trained and non-pre-trained models did not reveal evident differences, suggesting that the pre-training process does not introduce a significant computational overhead during the subsequent fine-tuning phase. RQ1: To what extent can state-of-the-art NMT models effectively generate offensive PowerShell code for security applications from NL descriptions? The evaluation of CodeT5+, CodeGPT, and CodeGen underscores their remarkable effectiveness in generating offensive PowerShell code for security applications from NL descriptions. CodeGen surpasses the other models in the 3 and 10 epochs settings according to all metrics. CodeT5+, designed with a specialized architecture for code generation tasks, consistently outperforms CodeGPT and CodeGen across various metrics in the 30 epochs setting. Particularly noteworthy is the comparison with SOTA performance in code generation tasks for different languages, such as Python and shell languages. Our best-performing model, CodeT5+ without pre-training and 30 fine-tuning epochs, surpasses the SOTA results, exhibiting superior performance across all metrics. Considering the impact of pre-training further enriched our evaluation. Focusing on the 3-epoch experiments, CodeT5+ exhibits a slight improvement across all metrics, and CodeGPT extends the improvement to 2%-4% across all metrics. Conversely, CodeGen appears to have better performance without pre-training. Training the models for 10 epochs reveals a more pronounced distinction between the two versions. CodeT5+ pre-training results in a 2% increase in both Edit Distance (ED) and METEOR metrics. CodeGPT, on the other hand, shows a substantial displacement of 1.7%, 3.5%, 4.6%, and 3.6% for BLEU-4, ED, METEOR, and ROUGE-L, respectively. CodeGen maintains a negative displacement between the versions even with the extended training duration. When extending the fine-tuning duration to 30 epochs, pre-training 8 \fNatural Language Intent Ground Truth Model Output Start a process with DirLister, wait for 4 seconds, and stop the DirLister process. Start-Process ${WebBrowserPassViewPath} ; Start-Sleep -Second 4 ; Stop-Process -Name \"WebBrowserPassView\" Start-Process ${WebBrowserPassViewPath} ; Start-Sleep -Second 4 ; Stop-Process -Name \"WebBrowserPassView\" Invoke-Mimikatz cmdlet with bypassed execution policy. powershell.exe -exec bypass -c \u201c Invoke-Mimikatz \u201d powershell.exe -ExecutionPolicy Bypass -Command \u201c Invoke-Mimikatz \u201d Invoke compiled HTML Help (CHM) file with specific storage handler, HH file path, and CHM file path. Invoke-ATHCompiledHelp -InfoTechStorageHandler $ { infotech_storage_handler } -HHFilePath $ { hh_file_path } -CHMFilePath $ { chm_file_path } Invoke-ATHCompiledHTMLHelp ((((((((((((( ( -InfoTechStorageHandler (((((((((((((((( ( $ { infotech_storage_handler } -HHFilePath $ { hh_file_path } -CHMFilePath $ { chm_file_path } Get the wininit process and perform token manipulation to create a new process for \u2019cmd.exe\u2019. Get-Process wininit | Invoke-TokenManipulation -CreateProcess \u2019cmd.exe\u2019 $wininit = Get-Process wininit | Invoke-TokenManipulation -CreateProcess \u2019cmd.exe\u2019 Table 5: Illustrative examples of model output. The prediction errors are red/bold. \u0018\u0018\u0018 \u0018 Slashed text refers to omitted predictions. did not consistently yield superior results. In this case, the performance of pre-trained models is comparable to non-pretrained counterparts. RQ2: What is the influence of the training strategies on NMT models\u2019 performance in offensive PowerShell code generation? As the fine-tuning period extends, such as with 10 and 30 epochs, the benefits of pre-training diminish or even become counterproductive. In these cases, the performance of pre-trained models consistently falls below that of their non-pre-trained counterparts. This highlights the variable effectiveness of pre-training, dependent on the duration of fine-tuning. These findings underscore the interplay between the duration of training epochs and the usage of pre-training, emphasizing the importance of carefully considering these factors in model development. Table 5 illustrates four cases of model predictions. They are examples from our test sets to highlight both successful and failed prediction cases. Row # 1 demonstrates the models\u2019 ability to generate a PowerShell snippet composed of multiple commands (separated by semicolons) without errors. The model correctly predicts the correct variables, e.g., WebBrowserPassViewPath, and command names, such as Start-Process, Start-Sleep. Row # 2 is indicative of the concept of implicit model knowledge. Indeed, the model can generate a correct command by leveraging alternative equivalent versions of PowerShell\u2019s option flags (e.g., -ExecutionPolicy instead of -exec). Row # 3 shows a relevant example of a failure case. It is possible to notice how the model correctly predicts the variable names and values except for one not referenced in the intent (-InfoTechStorageHandler). In addition, the model fails to predict the correct command name, generating an additional word (HTML) based on the NL description. Finally, row # 4 illustrates another incorrect example in which the model is capable of generating the ground truth code, except for introducing an additional variable to save the output of the command ($wininit =). Overall, we can conclude that these examples indicate the model\u2019s ability to generate complex PowerShell snippets, even though there is still some error margin, specifically related to omissions (e.g., variable names). 4.3 Static Analysis We evaluated the generated code through static analysis to ensure that the code adheres to PowerShell conventions and does not contain syntax errors. The analysis was conducted on the top-performing models identified in the previous evaluation, namely the 30-epoch versions of CodeT5+ with pretraining, CodeGPT without pre-training, and CodeGen with pre-training. The static analysis leverages PSScriptAnalyzer [67], a static code checker for PowerShell modules and scripts. The primary purpose of PSScriptAnalyzer is to assess the quality of PowerShell code by analyzing its syntax, structure, and adherence to best practices. The rules are based on PowerShell best practices identified by the PowerShell Team and the community, organized into categories such as Cmdlet Design, Script Functions, Error Handling, Scripting Style, and Script Security. The severity levels (ParseError, Error, Warning, Information) associated with each rule indicate the importance and impact of adhering to the specific guideline. In this work, we focused on parse errors, which occur during the parsing phase of a program\u2019s execution, errors, occurring when code 9 \fPre-trained models Static Analysis Test Set Reference  commands PSScript Analyzer Syntactic Evaluation NL Intents Generated commands Figure 3: Static analysis workflow. Model Single Accuracy (%) Comparative Accuracy (%) CodeT5+ 91.15 92.04 CodeGPT 98.23 98.23 CodeGen 98.23 98.23 Table 6: Syntactic evaluation for the best models. does not meet specific high-severity rules (e.g., hardcoding computer names, using plain text passwords), and warnings, which typically highlight potential issues or coding practices that might lead to errors or security concerns. We developed a syntactic analysis tool to streamline the process of detecting parse errors, errors, and warnings in PowerShell scripts. This tool automatically feeds PSScriptAnalyzer with PowerShell commands generated by the models during the testing phase. By doing so, our tool identifies errors and warnings in the generated code, assessing the overall syntactic quality of the models. The syntactic analysis process begins with our test set, which consists of NL intents paired with reference PowerShell commands. These NL intents are fed into fine-tuned models to produce the PowerShell code. Both the generated commands and their corresponding references are then subjected to the syntax analyzer. To assess the syntactic quality of the generated commands, we introduce two distinct metrics: Single Syntax Accuracy and Comparative Syntax Accuracy. The metrics are defined as follows: \u2022 Single Syntax Accuracy: evaluates the percentage of commands without parse errors. This evaluation is independent of the reference commands from the ground truth. \u2022 Comparative Syntax Accuracy: assesses the syntactic correctness of the generated commands by considering the results alongside the reference commands. When both commands present common parse errors, these are excluded from the counting process. Given that some reference commands include stub templates such as <code> Test Set ParseError (%) Error (%) Warning (%) CodeT5+ 8.85 1.94 35.92 CodeGPT 1.77 2.70 29.73 CodeGen 1.77 1.80 31.53 Ground Truth 2.65 0.00 39.09 Table 7: Summary of ParseError, Error, and Warning percentages for models and ground truth on the test set. 14 22 3 4 14 14 5 2 17 7 5 4 16 10 5 6 0 5 10 15 20 25 AvoidUsingInvokeExpression  AvoidUsingCmdletAliases  AvoidUsingWMICmdlet  UseDeclaredVarsMoreThanAssignments Number of Warnings Warnings  CodeT5+ CodeGPT CodeGen Ground Truth Figure 4: Counts for different warning types in each test set. or <command>, the analysis filters out parse errors associated with these templates, specifically the RedirectionNotSupported and MissingFileSpecification errors. The workflow for the syntactic analysis is depicted in Figure 3. Looking at the results in Table 6, it is possible to notice that all the models achieved a score greater than 90%, assessing their strong capability to generate syntactically correct code. CodeGPT and CodeGen, in general, demonstrate high performance across both syntax metrics. Table 7 summarizes the percentages for various severity types in the test set. Given that warning frequencies are consistently above 30% for all models, including the ground truth, Figure 4 enumerates the various warning types within each set. 4.4 Execution Analysis The execution analysis aims to evaluate the generated offensive PowerShell code when running in an actual system. This involves assessing the ability of the code to behave as intended in terms of effects caused on the system. Therefore, we run both code from the ground truth and generated code, monitor their behavior at runtime, and compare the behavioral events 10 \fExecution Analysis Windows 10 VM Pre-trained models Test Set Reference  commands NL Intents Generated commands Sysmon Security  Tools Event  Filtering Execution Evaluation Figure 5: Execution analysis workflow. Ground truth events Generated code events 188 151 145 powershell.exe -ExecutionPolicy Bypass -NoLogo -NonInteractive -NoProfile -WindowStyle Hidden -Command \"IEX (Invoke-WebxRequest \u2013Uri 'https://raw.githubusercontent.com/PowershellScripts-for-Hackers-and-Pentesters/main/scripts/all_in_one_enum.ps1').Content\"Whitecat18 powershell.exe -NoP -NonI -W Hidden -Exec Bypass -Command \"Invoke-WebRequest https://raw.githubusercontent.com/Whitecat18/Powershell-Scripts-for-Hackers-and-Pentesters/main/ scripts/all_in_one_enum.ps1 -OutFile hello.ps1; .\\hello.ps1\" pwsh.exe>C:\\Windows\\System32\\ntdll.dll pwsh.exe>C:\\Windows\\System32\\gdi32full.dll ... powershell.exe>C:\\Windows\\System32\\sxs.dll powershell.exe>C:\\Windows\\System32\\umpdc.dll pwsh.exe>C:\\Windows\\System32\\ntdll.dll pwsh.exe>C:\\Windows\\System32\\gdi32full.dll ... pwsh.exe>C:\\Program  Files\\PowerShell\\7\\System.Reflection.Metadata.dll pwsh.exe>C:\\Program  Files\\PowerShell\\7\\System.Collections.Immutable.dll Figure 6: Comparison between events. that occurred during their execution. The entire workflow for the execution analysis is shown in Figure 5. We performed the experiments in a controlled and dedicated testing environment. The controlled environment consists of a virtualized Windows 10 system running in VirtualBox 7. The system is equipped with a set of security-related tools, such as PowerSploit [68] and Mimikatz [69], that are invoked by many samples of offensive code in our dataset. We assume that these tools have been previously infiltrated by the attacker in a previous stage, as typical of advanced malicious campaigns. To monitor the execution of Powershell code, we integrated Sysmon [70], a popular Windows service for gathering system events, including the filesystem, the network, and the Windows Registry. To be able to run the generated code on the system, we assume the scenario in which an attacker already bypassed part of the security mechanisms by deactivating the Microsoft Defender Firewall, Windows Defender, and Microsoft Defender SmartScreen. The evaluation involved executing each command from both the generated ones and those from ground truth multiple times as a single-line PowerShell script. This generates a process through the standard Windows System.Diagnostics.Process. We filter the events recorded by Sysmon by filtering out records related to previous irrelevant Model Precision (%) Recall (%) F1-Score (%) CodeT5+ 97.26 80.94 88.35 CodeGPT 91.86 85.23 88.42 CodeGen 96.94 80.97 88.24 Table 8: Execution analysis results. events and selecting records based on the Process ID (PID), focusing on both the parent process responsible for executing the PowerShell command and its child processes. The comparison has been performed comparing the events triggered by the generated command (called retrieved records) to those from the execution profile of the ground truth (called relevant records). The events that appear both when executing the generated code and the ground truth are relevant records retrieved. From these sets of events, we evaluate the precision, recall and F1-score of the generated code, defined as follows: precision = 1 N N \u2211 i #(relevant records retrieved)i #(retrieved records)i recall = 1 N N \u2211 i #(relevant records retrieved)i #(relevant records)i F1-Score = 2 precision\u2217recall precision+recall Figure 6 illustrates an example of event analysis: given the ground truth and the generated PowerShell command, we execute them and compare the set of events triggered by each command to measure their overlap. To avoid noise in the analysis due to events that only occur sporadically (e.g., because of non-determinism sources in the system), we identify such events by performing multiple repeated runs of the code and discard non-reproducible events from the analysis. After every command execution, the Windows environment is restored to a clean state, by reloading the virtual machine from a snapshot, to avoid interferences caused by the effect of previous commands. The results shown in Table 8 outline how all models share an overall precision higher than 90% and an overall recall higher than 80%, likewise, the Execution F1-Score is very similar between the different models and higher than 88%. Thus, although there were differences found in the textual similarity analysis, the generated code closely matches the ground truth in terms of dynamic events. RQ3: How good is the generated code in terms of code quality and dynamic behavior? The syntactic analysis of the generated code showed that the models are indeed capable of generating high-quality 11 \fFigure 7: Comparison with ChatGPT on output similarity metrics. PowerShell code. CodeGPT and CodeGen achieve the best results in terms of Single and Comparative Accuracy, along with an amount of Warnings and ParseErrors comparable to the ground truth. The execution analysis revealed that the generated PowerShell code closely replicates the behavior of the ground truth code, generating the same events in the target system. This is indicative of the generated code\u2019s capability of performing the malicious actions described in the NL intents. 4.5 Comparison with Public AI Model In this study, we conducted a comprehensive evaluation by comparing the performance of our fine-tuned models, CodeT5+, CodeGPT, and CodeGen, with ChatGPT, the OpenAI LLM service widely used for a variety of tasks, including code generation [71]. The purpose was to assess the specialized capabilities of our models in generating PowerShell code for offensive security tasks and to benchmark their performance against a publicly available, closed-source model. We leveraged ChatGPT 3.5, which represents the most recent free version at the time of this work. To assess the capabilities of the OpenAI model, we first provided a detailed description of the required task, i.e., the generation of PowerShell commands starting from NL descriptions, including an example of input and the desired output. Then, we provided a list of natural language code descriptions and asked ChatGPT to automatically generate the corresponding PowerShell code. Specifically, following works and guidelines on prompt engineering [71, 72], we leveraged the following prompt: I want you to act as a code generator. Given a natural language description of a PowerShell command, generate the corresponding PowerShell code. Figure 7 shows the results of this analysis. The figure shows that our fine-tuned models consistently outperform ChatGPT Figure 8: Comparison with ChatGPT on static and execution analysis evaluation metrics. across multiple evaluation metrics. Specifically, ChatGPT exhibits a BLEU-4 score of 7.45%, an ED of 33.84%, a METEOR of 22.14%, and a ROUGE-L of 20.61%. In contrast, our fine-tuned models showcase superior overall performance across all output similarity metrics. The tailored training on the specialized fine-tuning dataset, designed specifically for offensive security code generation, results in more accurate code generation, enabling our models to surpass the capabilities of ChatGPT in this particular task. We also analyzed the syntactical quality of the PowerShell code generated by ChatGPT, obtaining a Syntax Single Accuracy of 95.58% and a Syntax Comparative Accuracy of 96.46%. These results underscore the commendable ability of ChatGPT to generate accurate and syntactically correct PowerShell code. Finally, we extended the execution analysis to ChatGPT, following the same strategies described in Section 4.4, obtaining an overall Execution F1-Score of 82.92%. Despite the strong syntactic performance, ChatGPT remains one step below the fine-tuned models in the qualitative analysis of the generated PowerShell code. The results of this analysis are shown in Figure 8. RQ4: How do fine-tuned NMT models, leveraging security-oriented training data, compare to a publicly available, closed-source model? The comparative analysis with ChatGPT, a publicly available general-purpose language model, highlights the specialized strengths of privately fine-tuned models, CodeT5+, CodeGPT, and CodeGen, in offensive PowerShell code generation. The fine-tuned models consistently outperform ChatGPT across BLEU-4, Edit Distance, and METEOR scores. While showing notable performance on syntactic accuracy, ChatGPT achieves poorer results than the fine-tuned models for the execution analysis. This underscores the significance of 12 \fdomain-specific fine-tuning and the benefits of training on security-oriented datasets, providing an advantage in generating offensive PowerShell code compared to a general-purpose language model. The results affirm the effectiveness of tailored training data for achieving superior performance in domain-specific tasks. 5 Threats To Validity Model selection. The external validity of the study might be impacted by the choice of NMT models (CodeT5+, CodeGPT, CodeGen). To mitigate this, we carefully selected models with distinct architectures and capabilities, ensuring a representation of current advancements in the field [16,73,74]. This careful selection aims to ensure that our findings reflect broader trends in NMT model performance for code generation tasks. Evaluation metrics. The reliance on output similarity metrics, although representing the most common solution in the field, poses a potential threat to construct validity, as these metrics may not fully encapsulate the correctness and functional adequacy of the generated PowerShell commands. To address this issue, our evaluation strategy encompasses a comprehensive suite of metrics, including similarity, syntactic, and execution metrics, each offering unique insights into the models\u2019 performance. By considering multiple variants of these metrics and aligning with common practices in code generation evaluation, we aim to provide a well-rounded assessment. No single metric is perfect, but analyzing them collectively allows for a more comprehensive evaluation of the code. Fine-tuning data. The construction of our dataset, meticulously curated from several sources such as online repositories, Atomic Red Team, Stockpile, and Empire, introduces potential limitations regarding the generalizability of our models\u2019 performance across different offensive security contexts. To minimize the impact of these limitations, we sourced data from diverse origins and conducted manual verification of each sample in the labeled dataset, ensuring the completeness and coherence of descriptions with the intended programs. The diversity in data sources and the thorough verification process aim to diminish the influence of any singular source\u2019s peculiarities and errors in programs or descriptions, thereby enhancing the dataset\u2019s applicability and reliability for training and evaluating AI models in generating offensive PowerShell code. Furthermore, our approach to crafting NL descriptions, inspired by established styles found in PowerShell literature, mirrors real-world scenarios where such descriptions play a critical role in describing PowerShell commands. Finally, regarding the size of our dataset, we notice that it is in line with other state-of-the-art corpora used to fine-tune models, which are in the order of one thousand samples [52]. 6 Ethical Considerations Recognizing that attackers use attacks as a weapon, it is important to specify that the goal of the proof-of-concept (POC) is not to cause harm but to surface security weaknesses within the software. Identifying security issues allows companies to patch vulnerabilities and protect themselves against attacks. Offensive security is a sub-field of security research that tests security measures from an adversary or competitor\u2019s perspective, employing ethical hackers to probe a system for vulnerabilities [75, 76]. Our work aims to automate attack generation to explore critical vulnerabilities before they are exploited by attackers [77]. Indeed, our work simplifies the process of coding the attacks to surface security weaknesses within the software and can provide valuable information about the technical skills, degree of experience, and intent of the attackers. With this information, it is possible to implement measures to detect and prevent attacks [78]. 7 Conclusion In this paper, we assessed the feasibility of using NMT models to generate PowerShell code for security contexts. We aimed to demonstrate that AI-based code generators are indeed fit to generate PowerShell code, specifically, offensive PowerShell, which spans several applications in the cybersecurity domain. The evaluation of CodeT5+, CodeGPT, and CodeGen demonstrated that these models achieve significant performance on the code generation task, both with and without pre-training. Moreover, the study showed that domain-specific fine-tuning allows our models to outperform state-of-the-art privately finetuned models, i.e., ChatGPT. We also introduced two novel datasets for PowerShell code generation to use for pre-training and fine-tuning AI-code generators. Future work includes further analysis of the generated code, such as sandbox execution of the offensive scripts, to understand whether the code can evade detection measures, along with more NMT models spanning several architectures and capabilities. Acknowledgments This work has been partially supported by MUR PRIN 2022, project FLEGREA, CUP E53D23007950001 (https://fl egrea.github.io) and by an Industrial Ph.D. grant (PNRR DM 117/2023) from MUR and DigitalPlatforms S.p.A, CUP E66E23000580003."
+        },
+        {
+            "url": "http://arxiv.org/abs/2404.14395v1",
+            "title": "PARAMANU-GANITA: Language Model with Mathematical Capabilities",
+            "abstract": "In this paper, we present Paramanu-Ganita, a 208 million parameter novel Auto\nRegressive (AR) decoder based language model on mathematics. The model is\npretrained from scratch at context size of 4096 on our curated mixed\nmathematical corpus. We evaluate our model on both perplexity metric and GSM8k\nmathematical benchmark. Paramanu-Ganita despite being 35 times smaller than 7B\nLLMs, outperformed generalist LLMs such as LLaMa-1 7B by 28.4% points, LLaMa-2\n7B by 27.6% points, Falcon 7B by 32.6% points, PaLM 8B by 35.3% points, and\nmath specialised LLMs such as Minerva 8B by 23.2% points, and LLEMMA-7B by 3.0%\npoints in GSM8k test accuracy metric respectively. Paramanu-Ganita also\noutperformed giant LLMs like PaLM 62B by 6.4% points, Falcon 40B by 19.8%\npoints, LLaMa-1 33B by 3.8% points and Vicuna 13B by 11.8% points respectively.\nThe large significant margin improvement in performance of our math model over\nthe existing LLMs signifies that reasoning capabilities of language model are\njust not restricted to LLMs with humongous number of parameters.\nParamanu-Ganita took 146 hours of A100 training whereas math specialised LLM,\nLLEMMA 7B, was trained for 23,000 A100 hours of training equivalent. Thus, our\napproach of pretraining powerful domain specialised language models from\nscratch for domain adaptation is much more cost-effective than performing\ncontinual training of LLMs for domain adaptation. Hence, we conclude that for\nstrong mathematical reasoning abilities of language model, we do not need giant\nLLMs and immense computing power to our end. In the end, we want to point out\nthat we have only trained Paramanu-Ganita only on a part of our entire\nmathematical corpus and yet to explore the full potential of our model.",
+            "authors": "Mitodru Niyogi, Arnab Bhattacharya",
+            "published": "2024-04-22",
+            "updated": "2024-04-22",
+            "primary_cat": "cs.CL",
+            "cats": [
+                "cs.CL",
+                "cs.AI",
+                "cs.LG"
+            ],
+            "label": "Original Paper",
+            "paper_cat": "LLM Fairness",
+            "gt": "PARAMANU-GANITA: Language Model with Mathematical Capabilities",
+            "main_content": "Introduction Pretrained Large Language Models (LLMs) (LLaMa (Touvron et al., 2023a), LLaMa-2, (Touvron et al., 2023b), PaLM (et al., 2022), Falcon (Almazrouei et al., 2023), Code LlaMa (Rozi\u00e8re et al., 2024), MPT 1, etc.) have demonstrated multidimensional abilities, such as in open-ended dialogue or instruction following (Ouyang et al., 2022) capabilities and being typically generalist language models balancing the performance across the entire distribution of natural language tasks. However, these generalist models are humongous in size and requires million dollars to train aside from high engineering inference cost involved. Traditionally, to optimize performance within specific domains such as finance (Wu et al., 2023), medicine (Singhal et al., 2023), etc., these models have been continued trained on domain specific data. However, domain specific continual pretraining of LLMs are also very expensive to our opinion. For employing a domain-specific LLM, lot of computation and inference costs are involved along with high requirement of GPUs. For example, to improve the mathematical reasoning capabilities of LLMs, LLEMMA 7B (Azerbayev et al., 2024) was trained on 256 A100 40GB GPUs for roughly 23,000 A100 training hours, which is yet very expensive. Instead of following the domain adaptation method of LLMs for better mathematical reasoning, we focused on pretraining from scratch a generative mathematical language model only on our curated high quality mathematical corpus. This avoids requiring immense compute power, high engineering maneuver and techniques to load LLMs in memory, and mostly high cost of training, and non-specialised tokenizer issue of existing LLMs. Following our previous work for domain adaptation (Niyogi and Bhattacharya, 2024b), we continued our exploration to see whether we can develop strong reasoning mathematical language model from scratch and compares how well it performs with respect to LLMs in mathematical reasoning benchmarks. We trained a powerful mathematical 1https://www.databricks.com/blog/mpt-7b arXiv:2404.14395v1  [cs.CL]  22 Apr 2024 \flanguage model from scratch which only required 146 hours of A100 training. Yet, our mathematical language model, Paramanu-Ganita outperformed LLEMMA 7B math specialised model on GSM8K (Cobbe et al., 2021) benchmark by significant margin of 3 percentage points despite being 35 times smaller in size. On the memory requirements, the LLEMMA 7B checkpoint size is 13.5GB whereas our model, Paramanu-Ganita checkpoint size is less than 1GB. Comparing with LLEMMA 7B training, we dropped the requirement of requiring 23,000 A100 hours of continual training to 146 hours of pretraining our mathematical language model from scratch. Our math model is based on Paramanu (Niyogi and Bhattacharya, 2024a), released earlier by us. We have trained an auto-regressive model from scratch at a context size of 4096 on a single NVidia A100-PCIE-40GB GPU. Our work is an attempt to make dedicated mathematical specialized model from scratch rather than performing continual pretraining of existing LLMs for domain adaptation. Our models are much smaller in size by large order of magnitude of LLMs, having only 208 million parameters. Hence, our models are very fast in inference without requiring any quantization of weights, and our math model can be run on CPU without need of GPU. Our main contributions are as follows: \u2022 We have curated an exclusive mathematical pretraining corpus with high quality mathematical text including textbooks, lecture notes, web crawled mathematical text, mathematical source code from various programming languages, mathematical ArXiV papers, mathematical question answers pairs from forums like StackExchange, Reddit. We also developed a math domain specialised tokenizer from scratch. \u2022 We developed first ever exclusive Auto Regressive decoder mathematical model of 208 million parameters only from scratch, Paramanu-Ganita at context size of 4096 respectively on a single GPU. We pretrained only on a part of our curated mathematical corpus and are yet to explore the full potential of the capabilities of our model. \u2022 We evaluated our mathematical pretrained models on validation perplexity, and on model FLOPs Utilization (MFU) metric for pretraining. Table 1 shows the validation perplexity and MFU metrics of pretraining. \u2022 We also benchmarked our math model on popular math benchmark, i.e, GSM8k on CoT prompting and compared with the generalist LLMs and math domain specialised LLMs. \u2022 Our model, Paramanu-Ganita 208M, outperformed LLaMa-1 (33B, 13B, 7B), LLaMa2 (7B, 13B), Falcon (40B, 7B) (Almazrouei et al., 2023), PaLM (62B, 8B), MPT (30B, 7B), Vicuna 13B (Chiang et al., 2023), and math-specialised LLMs like Minerva 8B (Lewkowycz et al., 2022), LLEMMA-7B on GSM8k benchmark by large significant margin despite being smaller by multiple orders of magnitude in size. 2 Background 2.1 Language Modeling This objective of the language modeling can formally described as maximizing the probability of a sequence of tokens w1, w2, . . . , wN P(w1, w2, . . . , wn) = n Y i=1 P(wi | w1, w2, . . . , wi\u22121) (1) where p(wt|w0, . . . wt\u22121) is the probability of token wt given the sequence of previous tokens w0, . . . , wt\u22121. The performance of a language model is generally being evaluated using the total cross-entropy loss, i.e, the negative log-likelihood of the observed data under the model under consideration, which for a given dataset is defined as: Avg Loss = \u22121 N n X i=1 log(P(wi | w1, w2, . . . , wi\u22121)) (2) Lower the loss better is the model but just computing the loss may be not intuitive. Therefore, perplexity is a metric to evaluate the performance of a given language model which is the exponent of the average loss. 2.2 Model Flops Utilization (MFU) Model Flops Uitilization (MFU) (Korthikanti et al., 2022) estimate is the ratio of the observed throughput (tokens-per-second), relative to the theoretical \fmaximum throughput of a system at peak FLOPs. Model flops utilization (MFU) estimate the number of flops we do per iteration. It quantifies how efficiently the GPUs are utilized in model training. 3 Data We have curated high quality mathematical text from mathematics text books, lecture notes, web such as OpenWebMath (Paster et al., 2023), blogs, articles, AlgebraStack (Azerbayev et al., 2024), mathematical question answers pairs from StackExchange, and math classified ArXiv scientific papers. We templatised the mathematical question answer tuples as CoT (Wei et al., 2023) prompt. The following template was used to templatise the mathematical question answers pairs such as \u201dBelow is an instruction that describes a task. Write a response that appropriately completes the request. ### Q:{question} ### A: Let\u2019s think step by step. {answer}\u201d We also included templatised training set of GSK8k in the pretraining dataset. Therefore, our combined mathematical corpus is a mix dataset of mathematical text, source code of programming languages like TeX, Python, C, Matlab, etc., and mathematical question answers tuples in CoT templatised format. 4 Related Work (Wei et al., 2023) boosts the reasoning capacity of LLMs by supplementing the output with a series of intermediate steps leading to the answer. Several approaches have been suggested to enhance the quality of these reasoning paths. For instance, Complexity-based CoT (Fu et al., 2023) picks examples with more steps as in-context demonstrations, demonstrating that prompting with additional reasoning steps improves performance. SelfConsistency (Wang et al., 2023b) generates multiple reasoning paths and selects the final answer through majority voting. Another set of techniques involves finetuning-based methods, which adapt open-source models (like LLaMA) using insights from advanced closed-source LLMs (GPT-4, and GPT-3.5-Turbo). (Magister et al., 2023) explore the transfer of reasoning abilities through knowledge distillation. (Yuan et al., 2023) advocate for the use of rejection sampling finetuning (RFT) to enhance mathematical reasoning performance. WizardMath (Choi et al., 2022) introduces a reinforced evol-instruct method for strengthening reasoning abilities through supervised fine-tuning and PPO training (Schulman et al., 2017). MAmmoTH (Yue et al., 2023) integrates CoT and Program-ofThought (Chen et al., 2023) rationales to teach LLMs how to utilize external tools (such as a Python interpreter) for solving mathematical problems. (Wang et al., 2023a) propose a constraint alignment loss for finetuning LLMs to improve calibration. 5 Training We have pretrained our math model, ParamanuGanita, from scratch at a context size of 4096 on a part of our curated corpus. However, we have excluded training of our math model on ArXiv math papers as we believe that to learn basic mathematical concepts, and acquire mathematical logical reasoning, ArXiv math papers are not required as they generally meant to serve beyond high school level mathematics. We started with simple strategy to use a part of our curated corpus which generally covers various mathematical and logical concepts till secondary school education in general. We performed mix-training combining both mathematical plain text, source code of programming languages, and templatised mathematical question answers pairs in the pretraining phase. For pretraining Paramanu-Ganita (4096 context size), we performed 95%-5% data split for pretraining, as we wanted to use most of the dataset for pretraining. We reported the validation perplexity of our pre-trained mathematical language model in table 1. We then fine-tuned the math model on the templatised GSM8k training dataset for 2 epochs. However, we are also working on training multiple pretrained models from scratch to check whether different combinations of mathematical books, web crawled mathematical text, ArXiv math papers, source code of relevant programming languages, and mathematical question answers pairs from popular forums such as StackExchange, Reddit improves the reasoning ability of our models based on popular math benchmark, GSM8K. 6 Evaluation We evaluate the model\u2019s ability to solve mathematics problems using chain of thought reasoning. Our evaluations include GSM8k (Cobbe et al., 2021), the de-facto standard benchmarks for evaluating quantitative reasoning in language models. We reported Pass@1 accuracy of Paramanu-Ganita as \fModel Perplexity MFU Paramanu-Ganita (4096) 4.34927 40.39193 Table 1: Perplexity and MFU metrics of ParamanuGanita pretrained models. shown in the table 2. We used the following evaluation prompt for GSM8k test set for our math model. \u201dBelow is an instruction that describes a task. Write a response that appropriately completes the request. ### Q:{question} ### A: Let\u2019s think step by step. \u201d Table 2 also reports the various LLMs and their reported scores quoted from the respective publications. Paramanu-Ganita despite being 35 times smaller than 7B LLMs, outperformed LLaMa1 7B by 28.4% points, LLaMa-2 7B by 27.6% points, Falcon 7B by 32.6% points, PaLM 8B by 35.3% points, Minerva 8B by 23.2% points, and LLEMMA-7B by 3% points respectively. Paramanu-Ganita also outperformed PaLM 62B by 6.4% points despite being smaller by 305 times, Falcon 40B by 19.8% points (smaller by 197 times), LLaMa-1 33B by 3.8% points (smaller by 162 times) and Vicuna 13B by 11.8 % points respectively despite being smaller by 64 times in model parameters. LLEMMA 34B, Minerva 62B, Minerva 540B are the giant LLMS that performed better than Paramanu-Ganita on GSM8k benchmark. However, as we have only trained our math model on a part of our entire corpus, so we hope its not a fair comparison to test the full potential of our math model, we also did not perform DPO or PPO training to improve the performance of our ParamanuGanita 208M compared to other math specialised LLMs. 7 Conclusions In this paper, we presented an exclusive mathematical Auto Regressive Decoder based language model, Paramanu-Ganita 208M, pretrained from scratch on a part of our entire mathematical corpus for a context size of 4096. We evaluated our mathematical model on validation perplexity and benchmarked our model on popular GSM8K math benchmark. We found that Paramanu-Ganita despite being 35 times smaller than 7B LLMs, outperformed generalist LLMs such as LLaMa-1 7B by 28.4% points, LLaMa-2 7B by 27.6% points, Falcon 7B by 32.6% points, PaLM 8B by 35.3% Model Parameters GSM8k Pass@1 LLaMa-1 33B 35.6 LLaMa-1 7B 11.0 LLaMa-2 13B 28.7 LLaMa-2 7B 11.8 Code LLaMa 7B 10.5 Code LLaMa 34B 29.6 Falcon 40B 19.6 Falcon 7B 6.8 MPT 30B 15.2 MPT 7B 6.8 GPT-J 6B 34.9 Vicuna 13B 27.6 PaLM 8B 4.1 PaLM 62B 33.0 Minerva 8B 16.2 Minerva 62B 52.4 Minerva 540B 58.8 LLEMMA 7B 36.4 LLEMMA 34B 51.5 Paramanu-Ganita 208M 39.4 Table 2: Evaluation of LLMs on GSM8k test set. PaLM, LLaMa-1 (Touvron et al., 2023a), LLaMa-2 (Touvron et al., 2023b), Falcon (Almazrouei et al., 2023), Code Llama (Rozi\u00e8re et al., 2024), MPT, Vicuna (Chiang et al., 2023), Minerva (Lewkowycz et al., 2022) (Lewkowycz et al., 2022) scores are quoted from respective author papers. points, math specialised LLMs such as Minerva 8B by 23.2% points, and LLEMMA 7B by 3% points in accuracy metric respectively. Paramanu-Ganita also outperformed PaLM 62B by 6.4% points, Falcon 40B by 19.8% points, LLaMa-1 33B by 3.8% points and Vicuna 13B by 11.8 % points in test accuracy metric of GSM8k respectively despite just having 208 million parameters only. However, we have not trained our model on the entire mathematical corpus so we have not yet explored the full potential of our model. We are currently working on extensive study to train multiple pretrained mathematical language models from scratch and of various sizes, somewhere in the same range, to explore the different combinations of mathematical books, web crawled mathematical text, ArXiv math papers, source code of relevant programming languages, and mathematical question answers pairs from popular forums such as StackExchange, Reddit to judge the full potential of our models and check how far the reasoning ability of our current \fmodel can be improved based on popular math benchmark, GSM8K and whether it performs better than the state-of-the-art LLM on GSM8k benchmark despite just being of 208 million parameters in size."
+        },
+        {
+            "url": "http://arxiv.org/abs/2404.12833v1",
+            "title": "How Far Can We Go with Practical Function-Level Program Repair?",
+            "abstract": "Recently, multiple Automated Program Repair (APR) techniques based on Large\nLanguage Models (LLMs) have been proposed to enhance the repair performance.\nWhile these techniques mainly focus on the single-line or hunk-level repair,\nthey face significant challenges in real-world application due to the limited\nrepair task scope and costly statement-level fault localization. However, the\nmore practical function-level APR, which broadens the scope of APR task to fix\nentire buggy functions and requires only cost-efficient function-level fault\nlocalization, remains underexplored. In this paper, we conduct the first\ncomprehensive study of LLM-based function-level APR including investigating the\neffect of the few-shot learning mechanism and the auxiliary repair-relevant\ninformation. Specifically, we adopt six widely-studied LLMs and construct a\nbenchmark in both the Defects4J 1.2 and 2.0 datasets. Our study demonstrates\nthat LLMs with zero-shot learning are already powerful function-level APR\ntechniques, while applying the few-shot learning mechanism leads to disparate\nrepair performance. Moreover, we find that directly applying the auxiliary\nrepair-relevant information to LLMs significantly increases function-level\nrepair performance. Inspired by our findings, we propose an LLM-based\nfunction-level APR technique, namely SRepair, which adopts a dual-LLM framework\nto leverage the power of the auxiliary repair-relevant information for\nadvancing the repair performance. The evaluation results demonstrate that\nSRepair can correctly fix 300 single-function bugs in the Defects4J dataset,\nlargely surpassing all previous APR techniques by at least 85%, without the\nneed for the costly statement-level fault location information. Furthermore,\nSRepair successfully fixes 32 multi-function bugs in the Defects4J dataset,\nwhich is the first time achieved by any APR technique ever to our best\nknowledge.",
+            "authors": "Jiahong Xiang, Xiaoyang Xu, Fanchu Kong, Mingyuan Wu, Haotian Zhang, Yuqun Zhang",
+            "published": "2024-04-19",
+            "updated": "2024-04-19",
+            "primary_cat": "cs.SE",
+            "cats": [
+                "cs.SE"
+            ],
+            "label": "Original Paper",
+            "paper_cat": "LLM Fairness",
+            "gt": "How Far Can We Go with Practical Function-Level Program Repair?",
+            "main_content": "INTRODUCTION Fixing software defects costs developers a significant amount of time and effort [34]. To assist developers in reducing the burden of repairing programs, Automated Program Repair (APR) techniques have been proposed to automatically generate potential patches for buggy programs. Specifically, the learning-based APR techniques which incorporate the learning power to advance the repair performance have been increasingly studied in recent years. For instance, many such techniques [30, 39, 49, 56, 81, 82, 89] utilize Neural Machine Translation (NMT) [68] such that APR is modeled as a translation task where the objective is to transform buggy code into correct code. More recently, Large Language Models (LLMs) have become largely adopted in various downstream software tasks [31, 32, 42, 47] including APR [38, 40, 62, 74, 75, 77, 79] where they have been proven to advance the repair performance [33, 38, 75\u201377], e.g., the Codex model can fix 32 more bugs than previous APR techniques in the Defects4J 1.2 dataset [76]. Meanwhile, researchers also propose multiple LLM-based APR techniques [40, 71, 74, 77\u2013 79] to further enhance the repair performance. For instance, the state-of-the-art LLM-based APR technique ChatRepair [79] employs a conversational repair mechanism and successfully fixes 162 out of 337 bugs in a crafted Defects4J dataset, causing at least 24.6% gain compared with all existing techniques. However, many LLM-based APR techniques are proposed for the single-line or hunk-level program repair by auto-completing a single line [45] or infilling a hunk of code with context [77] respectively. They typically rely on identifying statement-level program faults, i.e., given fault locations [37, 74, 75, 77, 85] or applying statement-level fault localization techniques such as Gzoltar [71]. Nevertheless, it has been widely argued that accurately identifying statement-level faults can be essentially costly, i.e., demanding fine-grained input or strong assumptions [21, 24, 52, 66], thus potentially limiting the real-world applicability of the single-line or hunk-level APR. On the other hand, the LLM-based function-level APR can be potentially more promising, i.e., applying a generative model such as an LLM to auto-regressively generate the entire patched version of the buggy function by prompting the buggy function into the LLM. To illustrate, first, the function-level APR enables a larger scope of the program repair task\u2014it involves not only the singleline and hunk-level repair tasks, but also a more complicated task which repairs multiple discontinuous lines or hunks within a function [65]. Second, identifying function-level faults tends to be more cost-efficient than identifying statement-level faults, thus rendering the function-level APR more practical in real world [44, 48, 55]. arXiv:2404.12833v1  [cs.SE]  19 Apr 2024 \fConference\u201917, July 2017, Washington, DC, USA Jiahong Xiang, Xiaoyang Xu, Fanchu Kong, Mingyuan Wu, Haotian Zhang, and Yuqun Zhang While LLM-based function-level APR techniques are more promising, there lacks sufficient study and understanding of them [76], thus potentially hindering the further improved usage of LLMs for APR. Specifically, first, the existing LLM-based APR techniques exhibit significant performance loss for the function-level APR, e.g., incurring a decrease of 33% in ChatRepair and 36.4% in CodexRepair [76, 79] in terms of correctly fixed bugs. Second, the rationale of how such techniques can be affected has not been fully investigated. More specifically, the effectiveness of certain commonly-used mechanism such as the few-shot learning [40, 76, 79], i.e., prompting buggy code and fixed code pair examples that illustrate the function-level APR task and provide repair context for advancing the learning power of models, remains inadequately validated. Additionally, the potential of incorporating the auxiliary repair-relevant information, such as bug reports and trigger tests, remains underexplored [33, 62, 79]. Thus, there is an urgent need to extensively study the LLM-based function-level APR to further enhance the repair performance. In this paper, we conduct the first comprehensive study on the function-level LLM-based APR including investigating the effect of the few-shot learning and the auxiliary repair-relevant information. Specifically, we adopt six widely-studied LLMs including the state-of-the-art LLMs such as Codex-edit and GPT-3.5Turbo [33, 79, 85, 86] as the study subjects. We also construct a benchmark containing 522 single-function bugs, i.e., the bugs existing within one single function, in the Defects4J dataset. Typically, we build our repair prompt containing the buggy function along with (1) the buggy code and fixed code pair examples to utilize the few-shot learning mechanism; and (2) the auxiliary repair-relevant information such as trigger tests for the studied LLMs respectively. In this way, the entire patched functions can be auto-generated and then validated with the Defects4J test suite to derive the plausible patches (which pass all the tests). Our evaluation results demonstrate that incorporating the few-shot learning mechanism in the function-level APR actually causes significantly disparate and even negative impacts on the average number of plausible fixes compared with applying the default LLMs only, i.e., from an increase of 10% to a decrease of 49.7% among all studied LLMs. Surprisingly, we find that directly applying trigger tests or error messages for prompting can significantly enhance the repair performance, e.g., 26.7% and 26.1% improvement in terms of the average number of plausible fixes respectively. On the other hand, while statementlevel fault location information is shown powerful essential to many APR techniques, only adopting the easier-to-obtain auxiliary repairrelevant information including trigger tests, error messages, and comments altogether for prompting can achieve rather close performance, i.e., causing merely 7.1% gap in terms of the number of plausible fixes. Such a result indicates the potential of replacing the costly statement-level fault location information for the LLM-based function-level APR. In our study, over 10 million patches are generated and validated, consuming more than 8,000 GPU and 100,000 CPU hours. To our best knowledge, this is the largest empirical study of LLM-based APR conducted to date. Inspired by our findings, we propose an LLM-based functionlevel APR technique, namely SRepair, which adopts a dual-LLM framework to leverage the power of the auxiliary repair-relevant information for advancing the repair performance. In particular, SRepair first adopts a repair suggestion model which employs the Chain of Thought (CoT) technique [72] to generate naturallanguage repair suggestions. More specifically, SRepair prompts the LLM with the buggy function and the auxiliary repair-relevant information (i.e., trigger tests, error messages, and comments) to identify the root causes of the bugs and generate repair suggestions in natural language accordingly. SRepair then adopts a patch generation model to auto-generate a patched function with the assistance of the repair suggestions. Our evaluation demonstrates that SRepair can correctly fix a total of 300 single-function bugs in our Defects4J dataset, largely surpassing all previous APR techniques, e.g., 1.59\u00d7 more than Repilot [74] and 85% more than ChatRepair [79], without the need for the costly statement-level fault location information. Moreover, 128 bugs out of them were not fixed by any of the baseline LLM-based APR techniques adopted in this paper. Surprisingly, SRepair is also capable of repairing 32 multi-function bugs, i.e., bugs existing across multiple functions at the same time, which, to our best knowledge, is the first time achieved by any APR technique ever. To summarize, this paper makes the following contributions: \u2022 We perform the first ever extensive study on the LLM-based function-level APR with the impact factors on its performance, paving the way for new directions in future research. \u2022 We find that LLMs with zero-shot learning are already powerful function-level APR techniques. We also find that applying auxiliary repair-relevant information can substantially improve the repair performance for all studied LLMs. \u2022 We propose a new LLM-based function-level APR technique, SRepair, which can achieve remarkable repair performance by correctly fixing 300 single-function bugs, largely surpassing the SOTA techniques, i.e., outperforming ChatRepair [79] by 85% and Repilot [74] by 1.59\u00d7 in the Defects4J dataset. Moreover, SRepair successfully fixes 32 multi-function bugs, which is the first time achieved by any APR technique ever to our best knowledge. 2 BACKGROUND & RELATED WORK 2.1 Large Language Model Large Language Models (LLMs) contain billions of parameters and are trained on petabyte-scale datasets. They are typically built based on the Transformer architecture [70] comprising an encoder for input processing and a decoder for output token generation. In particular, the decoder-only models as shown in Figure 1a have demonstrated superior text comprehension [61] and code generation capabilities [23]. Thus, they have garnered significant interest of researchers and been widely applied to various downstream tasks in software engineering, e.g., test case generation [42, 47], vulnerability detection [31, 32], and program repair [33, 37, 77]. These models when integrating domain-specific knowledge for specific tasks, are often fine-tuned [67] for further improving their performance. For instance, CodeLlama [63] is fine-tuned based on Llama 2 [69] for generating and discussing code, and Magicoder [7] is fine-tuned with OSS-Instruct [73] to enhance the code generation performance. While fine-tuning requires significant computational resources and specialized datasets [29], simpler prompting strategies like few-shot learning [26] and Chain of Thought (CoT) [72] \fHow Far Can We Go with Practical Function-Level Program Repair? Conference\u201917, July 2017, Washington, DC, USA // Buggy Function  public double getNumericalMean() {\u2026} GPT-3.5 Decoder for(int cnt = 0;  Decoder-only for(int cnt = 0; cnt OSS-Instruct RLHF CodeLlama Magicoder Codex Code Training // Buggy Function int binarySearch(\u2026) {Buggy Code} // Fixed Function int binarySearch(\u2026) {Fixed Code} Few-shot learning on APR task // Buggy Function  Same Buggy Project: Historical Buggy Code Example  // Fixed Function  Same Buggy Project: Historical Fixed Code Example (a) (b) Figure 1: Decoder-only models and few-shot learning on APR which have also been shown effective are much less costly and thus have been increasingly adopted [20, 84, 88]. Figure 1b illustrates how the few-shot learning mechanism is applied for APR. Firstly, the APR task-related examples such as the buggy and fixed code pair of the function binarySearch are incorporated into the prompt. Note that the example selection varies among different techniques, e.g., manually crafting examples like binarySearch [76] and choosing examples of historical bug fixes within the same buggy project [76, 79]. Next, the target buggy function to be fixed, e.g., getNumbericalMean() in the Math-2 bug [14], is also added to the prompt. At last, the resulting prompt is fed to the model to generate patches for the target buggy function. To summarize, the purpose of the few-shot learning mechanism is to enable the model to learn how to handle specific tasks through the examples. However, while multiple LLM-based APR techniques have already incorporated the few-shot learning mechanism [40, 76, 79], its impacts and characteristics remain unexplored. 2.2 Automated Program Repair Automated Program Repair (APR) techniques [33, 39, 40, 46, 56, 74\u2013 77, 81], designed to aid developers in fixing bugs by automatically generating patches, typically follow the Generate-and-Validate (G&V) paradigm [54]. In particular, an APR process refers to locating program faults, generating patches for the buggy locations, and validating such patches against a test suite to determine their plausibility (i.e., whether they could pass all tests). Eventually, these resulting plausible patches are manually reviewed to select the correct fix for the target fault. Notably, the trigger tests in the patch-validating test suite are manually created by developers. During the execution of trigger tests, the unit testing framework, e.g., JUnit [5], can be used to provide the corresponding error messages. Among the APR techniques, the learning-based techniques [39, 49, 56, 74, 77, 79, 81] that utilize deep learning techniques have recently achieved remarkable performance. Specifically, many such techniques widely adopt the Neural Machine Translation (NMT) [68] techniques which convert APR into a translation task to transform buggy code into correct code. They typically leverage the power of the NMT models through training on extensive datasets containing millions of buggy and fixed code pairs. However, such techniques are highly costly when building well-constructed datasets of buggy and patch code pairs [77] and specific context representation for the NMT models [39]. More recently, Large Language Models (LLMs) have become increasingly adopted in various downstream software tasks including APR. In particular, directly applying models like Codex can already outperform all previous APR techniques [76]. Meanwhile, multiple LLM-based APR techniques have been proposed to further enhance the repair performance. For instance, AlphaRepair [77] applies the pre-trained CodeBERT model with the \u201ccloze-style\u201d APR, i.e., removing the buggy code tokens and applying the LLM to generate the correct ones. Similar as AlphaRepair in adopting the cloze-style repair paradigm, Repilot [74] focuses on synthesizing compilable patches, utilizing the Language Server Protocol to prune infeasible tokens and proactively complete tokens as suggested by the LLM. FitRepair [75] combines LLMs with domainspecific fine-tuning and prompting strategies, fully automating the plastic surgery hypothesis, i.e., the code ingredients to fix bugs usually already exist within the same project. ChatRepair [79] utilizes the conversational repair mechanism based on GPT-3.5 and successfully fixes 162 out of 337 bugs in the Defects4J dataset with the assistance of the rich information from original bug-exposing tests. Fan et al. [33] conduct a study to investigate whether APR techniques can correct program errors generated by LLMs, particularly in complex tasks like the LeetCode contests. Another study [76] employs the few-shot learning mechanism and recognizes the ineffectiveness of simply feeding LLMs with only buggy functions as they are not pre-trained for APR. To address this, they create a prompt containing two pairs of buggy and fixed code examples: one manually crafted, and another from the same project or dataset. Then they include the buggy function to be fixed in this prompt, thus activating the function-level APR by providing such a prompt to LLMs. However, their claim that LLMs cannot be directly applied to the function-level APR and the effectiveness of employing the few-shot learning mechanism has not been fully investigated. private boolean flipIfWarranted(\u2026) {     if(1.5 * work[pingPong] < work) {      int j = 4 * n 1; +      int j = 4 * (n 1);        for(\u2026) { \u2026}} Single-line Bug (Math-80) Single-Hunk Bug (Math-91) Single-Function Bug (Math-95) protected double getInitialDomain(\u2026) {   double ret; +   double ret = 1.0;     double d = getDenominator\u2026(); +   if (d > 2.0) {        ret = d / (d 2.0); +    }\u2028 \u2026} public int compareTo(\u2026) { \u2026  double nOd = doubleValue();  double dOn = object.doubleValue(); +  long nOd = \u2026numerator*denominator; +  long dOn = \u2026denominator*numerator; \u2026} Figure 2: Bug examples existing in a single line, hunk, or function The existing LLM-based APR techniques mainly focus on repairing single-line or single-hunk bugs [74, 75, 77, 85], as illustrated \fConference\u201917, July 2017, Washington, DC, USA Jiahong Xiang, Xiaoyang Xu, Fanchu Kong, Mingyuan Wu, Haotian Zhang, and Yuqun Zhang in Figure 2. Specifically, the single-line bug Math-80 [15] is contained within a single line of the function flipIfWarranted where fixing this line alone can resolve the bug. Such a single-line bug can be fixed by APR techniques focusing on the line-level repair like AlphaRepair [77] given accurate fault locations. Meanwhile, the single-hunk bug Math-91 [16] is contained in a continuous section of code where two contiguous buggy lines are replaced in the fixed version. This kind of bugs can be fixed by the hunk-level APR techniques like Repilot [74] requiring multiple accurate statementlevel fault locations. Note that single-line and single-hunk bugs can be considered as part of single-function bugs. On the other hand, the bugs existing in multiple discontinuous sections/lines within a function and requiring simultaneous edits on them for a fix are also referred to as single-function bugs. For instance, fixing the Math-95 bug [17] requires editing three discontinuous lines simultaneously. It can be easily derived that fixing single-function bugs poses a greater challenge for APR techniques, e.g., the state-of-the-art APR techniques like ChatRepair and CodexRepair incur a performance decrease of 33% and 36.4% [79] in terms of the number of correctly fixed bugs for the function-level APR respectively. As mentioned, single-function bugs actually include single-hunk and single-line bugs as subset, i.e., enabling a larger scope of repair tasks. Moreover, locating function-level bugs tends to be cheaper than locating line-level or hunk-level bugs [21, 48, 55], thus making the function-level APR more practical. Therefore, we consider developing the function-level APR techniques rather promising and worthy being sufficiently investigated. 3 EMPIRICAL STUDY 3.1 Study Setup 3.1.1 Study Subjects. We utilize six distinct LLMs as our study subjects, encompassing the widely used state-of-the-art Codexedit and GPT-3.5-Turbo [33, 76, 79, 86], along with four advanced open-source code LLMs including CodeLlama 7B, 13B, and 34B (over 500k downloads on Hugging Face within one month [6]), and Magicoder 7B (over 1000 stars on GitHub [7]). Specifically, we adopt code-davinci-edit-001 [8], gpt-3.5-turbo-1106 [18], and the CodeLlama-Instruct series [6] models as the versions of as Codexedit, GPT-3.5-Turbo, and CodeLlama respectively since they have conducted the instruction fine-tuning [63] and can better follow the APR prompt instruction. We also employ the MagicoderS-CL [7] model as the version of Magicoder. Due to the page limit, the LLM configuration details are presented in our GitHub page [1]. 3.1.2 Dataset. We construct our benchmark using both the versions 1.2 and 2.0 of the Defects4J dataset [41] which is the most widely used APR dataset [39, 57, 76] with a collection of a total of 835 real-world bugs extracted from open-source Java projects, comprising both buggy and fixed versions of the source code. Notably, we bound our study scope within 522 single-function bugs including 276 single-hunk (\u201cSH\u201d) bugs and 158 single-line (\u201cSL\u201d) bugs as shown in Table 1. It should be noted that our collected singlefunction bugs already include all the single-line and single-hunk bugs studied in previous works [74\u201377, 79]. 3.1.3 Evaluation Metrics. To assess the repair performance, we follow the standard practice [35, 43, 60], to utilize the plausible Table 1: Statistics of the Dataset Dataset Project # Bugs SH Bugs SL Bugs Defects4j 1.2 Chart 16 12 9 Closure 105 59 26 Lang 42 23 13 Math 74 35 23 Mockito 24 12 7 Time 16 6 3 Defects4j 2.0 Cli 28 13 6 Codec 11 9 8 Collections 1 1 1 Compress 36 16 5 Csv 12 7 4 Gson 9 5 4 JacksonCore 13 9 5 JacksonDatabind 67 26 15 JacksonXml 5 1 1 Jsoup 53 38 27 JxPath 10 4 1 Overall 522 276 158 patches that pass all test cases as our major evaluation metric. In particular, those test cases include the trigger tests in the Defects4J dataset designed to expose bugs and relevant tests which can load the classes associated with the buggy functions. 3.2 Research Questions We investigate the following research questions for extensively studying the function-level APR along with the factors which can impact its effectiveness. \u2022 RQ1: How does the LLM-based function-level APR perform under the zero-shot and few-shot learning setups? For this RQ, we attempt to investigate the performance of the LLM-based function-level APR under the default zero-shot learning and explore the performance impact from adopting few-shot learning. \u2022 RQ2: How do different auxiliary repair-relevant information affect the LLM-based function-level repair performance? For this RQ, we attempt to study the impact from different auxiliary repairrelevant information including bug reports, trigger tests, etc., on the function-level repair performance. 3.3 Implementation We obtain the model from Hugging Face [2] and access Codexedit and GPT-3.5-Turbo through API [3] provided by OpenAI. Our default setting for patch generation uses the nucleus sampling with top \ud835\udc5d= 0.9, temperature = 0.8 and 200 samples per bug following prior works [28, 62, 76]. Patches are generated on servers with 128-core 2.6GHz AMD EPYC\u2122ROME 7H12 CPU, 512 GiB RAM and eight NVIDIA A100 80GB GPUs, running Ubuntu 20.04.6 LTS. 3.3.1 APR input prompt setup. Following prior studies [62, 76], we set the prompt for the LLM utilized in the APR task, as illustrated in Figure 3 to enable the function-level APR. Specifically, we begin with a description of the APR task as \u2018Provide a fix for the buggy function\u2019. Next, we incorporate the buggy code and fixed code pair examples from the few-shot learning mechanism or \fHow Far Can We Go with Practical Function-Level Program Repair? Conference\u201917, July 2017, Washington, DC, USA // Provide a fix for the buggy function {Buggy code and fixed code pair examples} OR {Auxiliary repair-relevant Information}\u2028 // Buggy Function public double getNumericalMean() {         return (double) (getSampleSize() *   getNumberOfSuccesses()) / (double) getPopulationSize();} // Fixed Function Figure 3: The input prompt for the function-level APR of the Math-2 bug Table 2: K-shot learning settings and abbreviations K Example Type Abbreviation 0 N.A. K0(Basic) 1 Crafted Example K1(CE) 1 Project Example K1(PE) 2 Crafted Example & Project Example K2(CE, PE) 2 Project Example & Project Example K2(PE, PE) the auxiliary repair-relevant information into the prompt. Subsequently, we use \u2018Buggy Function\u2019 in conjunction with the buggy code, e.g., the Math-2 buggy function getNumericalMean [14] in Figure 3, to prompt LLMs with the buggy function to be fixed. Finally, we apply \u2018Fixed Function\u2019 to guide the LLM in generating a patched function. Notably, we employ the zero-shot learning approach as the default baseline in our study, i.e., adopting no auxiliary repair-relevant information or buggy-fixed code pair examples for prompting. 3.3.2 K-shot learning setups. Table 2 presents our k-shot learning setups. Specifically, we set the zero-shot learning approach, i.e., adopting no pairs of buggy code and fixed code examples (K=0), as our basic setup denoted as K0(Basic). Moreover, we follow prior work [76] to form our buggy and fixed code pair examples via manually crafted examples (CE), i.e., binarySearch in Figure 1b and chosen historical bug fix examples within the same buggy project (PE). We thus form our k-shot learning setup variants as K1(PE) with only one chosen historical bug fix example from the same project, K1(CE) with only one manually crafted example, and K2(CE, PE) with one manually crafted example and one chosen historical bug fix example from the same project. We also form K2(PE, PE) with two chosen historical bug fix examples from the same project following the implementation of the prior work for selecting multiple examples [19]. Note that while it is possible for more setup variants, e.g., with more manually crafted examples and chosen historical bug fix examples from the same project, we generally follow the setup of prior work [76] for fair performance comparison and cost-efficient evaluations. 3.3.3 Collecting auxiliary repair-relevant information. In this study, we refer to the auxiliary repair-relevant information as the bug report and project-specific information from the target buggy project following prior works [46, 64, 79, 81, 83], as the Math-2 bug shown in Figure 4. Specifically, the bug reports are collected from the official issue links of the Defects4J [4] repository. More specifically, following prior works [27, 87], we divide a bug report into two parts, as (a) Bug Report (b) Project-specifi Comment Issue Title Issue 1021: HypergeometricDistribution.sample suffers from integer overflow Issue Description \u201cHi, I have an application which broke when ported from commons math 2.2 to  3.2. It looks like the HypergeometricDistribution.sample() method doesn't work  as well as it used to with large integer values, the example code below should  return a sample between 0 and 50, but usually returns -50\u2026\u201d Trigger Test Error Message public void testMath1021() { \u2026 for (\u2026) {   Assert.assertTrue(0 <= sample);         Assert.assertTrue(sample <= n);  }} AssertionFailedError: sample=-50 at HypergeometricDistributionTest.java:297 /* For population size {@code N}, number  of successes {@code m}, and sample*size  {@code n}, the mean is {@code n*m/N}. */ Figure 4: The bug report and project-specific information in the Math-2 bug illustrated in Figure 4a. One is the issue title with averagely around 12 tokens to summarize the type and the cause of the bug (e.g., \u201cIssue 1021: ... suffers from integer overflow\u201d). The other is the issue description with averagely 234 tokens which provides detailed conditions, error messages, and reproduction steps, etc. For instance, the issue description in the Math-2 bug report provides a detailed description of the buggy method HypergeometricDistribution.sample() with the trigger conditions, i.e., \u201cwith large integer values\u201d. Furthermore, we automatically extract the project-specific information from the buggy project, as the Math-2 bug in Figure 4b following the prior works [62, 79, 81]. Specifically, we first build all the buggy projects and automatically extract all the trigger tests and buggy function comments. Then, for each bug, we execute the trigger tests and capture the error messages generated by the unit test framework, such as Junit [5]. Notably, among all 522 singlefunction bugs in the Defects4J dataset, only 10 miss reports and 2 miss comments. We then leave such auxiliary repair-relevant information empty in our study. For evaluating the impact from the auxiliary repair-relevant information, we form eight different setups. Specifically, for bug report-relevant information, we form three setups: BR(IT) with the issue title only, BR(ID) with the issue description only, and BR(ALL) with the whole bug report. For the project-specific information, we form four setups: PI(TT) with the trigger test only, PI(EM) with the error message only, PI(BC) with the buggy comment only, and PI(ALL) with all such information. 3.4 Result Analysis 3.4.1 RQ1: the function-level repair performance. Table 3 presents the function-level APR results in terms of the number of plausible fixes. In general, we observe that K0(Basic) achieves the overall optimal plausible fix results, i.e., 180 average plausible fixes out of our collected 522 single-function bugs, outperforming all the rest setups by at least 10.4%. Such a result indicates that LLMs themselves (with zero-shot learning) are already powerful functionlevel APR techniques. \fConference\u201917, July 2017, Washington, DC, USA Jiahong Xiang, Xiaoyang Xu, Fanchu Kong, Mingyuan Wu, Haotian Zhang, and Yuqun Zhang Table 3: APR results under different few-shot learning setups Settings Codex-edit GPT-3.5-Turbo CodeLlama Magicoder Average Plausible Fixes 7B 13B 34B K0(Basic) 174 175 192 179 160 199 180 K1(CE) 103 138 180 185 176 112 149 K1(PE) 109 174 194 193 153 157 163 K2(CE, PE) 138 166 175 189 125 100 149 K2(PE, PE) 165 187 167 189 128 121 160 Finding 1: LLMs with zero-shot learning are already powerful function-level APR techniques. Interestingly, we can further observe that applying the few-shot learning mechanism leads to quite disparate plausible fix results across LLMs. For instance, compared with K0(Basic), while CodeLlama 34B shows a 10% (176 vs. 160) improvement in K1(CE), Magicoder shows a 49.7% (100 vs. 199) decline in terms of the number of plausible fixes. Finding 2: Applying the few-shot learning mechanism in the function-level APR leads to disparate plausible fix results across LLMs. K (Basic) K (CE) K (PE) K (CE, PE) K (PE, PE) 0 25 50 75 100 Plausible Test-failure Uncompilable Patch Ratio(%) 0 1 1 2 2 Figure 5: Patch status averaged across all models under different few-shot learning setups Furthermore, we present the distribution of plausible, test-failure, and uncompilable patches given the identical total number of generated patches across different LLMs under all setups in Figure 5. Note that the test-failure patches can be successfully compiled but fail one or more tests in our Defects4J dataset. Interestingly, we can find that K0(Basic) achieves the best plausible patch rate 4.3% and the lowest uncompilable patch rate 30.2% among all the k-shot setups, while applying the few-shot learning generates more uncompilable patches, i.e., ranging from 38.4% to 59.6% more than K0(Basic). Finding 3: Applying the few-shot learning mechanism may generate more uncompilable patches than the zero-shot learning mechanism. 3.4.2 RQ2: performance impact from the auxiliary repair-relevant information. Noticing that since applying zero-shot learning achieves the optimal repair performance among all the k-shot learning techniques as mentioned, we also adopt zero-shot learning in our auxiliary repair-relevant information evaluations and K0(Basic) as a baseline for a fair performance comparison. Table 4 presents the K0(Basic) BR(ALL) BR(IT) BR(ID) (a) Venn diagram public void visit(\u2026) { \u2026 if (!NodeUtil.isObjectLitKey(\u2026)){ ensureTyped(\u2026) +  } else { // Object literal keys are not typeable +   typeable = false; } } (b) Closure-66 bug Figure 6: The Venn diagram of plausible fixes over different setups and the bug Closure-66 which can only be fixed in K0(Basic) APR results under different auxiliary repair-relevant information setups. We observe that using bug report-relevant setups significantly enhances the repair performance of all models, i.e., the number of average plausible fixes increases from 180 in K0(Basic) to 238 in BR(IT), 270 in BR(ID), and 273 in BR(ALL). On the other hand, while BR(ALL) achieves the optimal result, Figure 6a also shows that it misses fixing 19 bugs which can be fixed in K0(Basic). More specifically, we can observe that five bugs can only be fixed in K0(Basic) other than all the rest setups, such as Closure-66 [11] in Figure 6b. We find that to fix such a bug, a simple branch condition must be added to set typeable false. In K0(Basic), four models successfully fix this bug. However, in BR(IT), BR(ID), and BR(ALL), the focus is incorrectly placed on the issue described in the bug report, leading to inappropriate code logic changes. Consequently, none of the six models are able to fix the bug. Finding 4: While applying the bug report-relevant information significantly enhances the function-level repair performance, it still misses fixing certain bugs which can be fixed by the baseline technique. We also attempt to investigate the performance impact from the project-specific information on the LLM-based function-level APR. Table 4 shows that using project-specific information setups leads to an increase for all models, i.e., the average number of plausible fixes rises from 180 in K0(Basic) to 185 in PI(BC), 227 in PI(EM), 228 in PI(TT). Notably, PI(ALL) achieves an optimal average of 254 plausible fixes, indicating the potential of leveraging as much auxiliary repair-relevant information as possible for enhancing the function-level repair performance. Interestingly, unlike adopting the bug report-relevant information, all the bugs plausibly fixed in K0(Basic) can also be fixed by adopting the project-specific information. \fHow Far Can We Go with Practical Function-Level Program Repair? Conference\u201917, July 2017, Washington, DC, USA Table 4: APR result in different auxiliary repair-relevant information settings Sources Settings Codex-edit GPT-3.5-Turbo CodeLlama Magicoder Average Plausible Fixes 7B 13B 34B N.A. K0(Basic) 174 175 192 179 160 199 180 Bug Report Information BR(IT) 265 233 234 221 221 251 238 BR(ID) 281 286 261 264 248 279 270 BR(ALL) 301 285 275 260 255 260 273 Projectspecific Information PI(BC) 186 185 187 191 169 194 185 PI(EM) 217 226 239 225 217 240 227 PI(TT) 239 247 227 221 201 235 228 PI(ALL) 264 273 249 247 236 254 254 Table 5: APR results with fault location information Sources Settings w/o \u2020FL w/ \u2020FL Improvement N.A. K0(Basic) 180 217 20.6% Bug Report Information BR(IT) 238 262 10.1% BR(ID) 270 289 7.0% BR(ALL) 273 291 6.6% Projectspecific Information PI(BC) 185 217 17.3% PI(EM) 227 257 13.2% PI(TT) 228 246 7.9% PI(ALL) 254 272 7.1% \u2020FL refers to fault location information. Finding 5: Directly adopting trigger tests, error messages, and comments from buggy projects can also effectively advance the function-level repair performance. We further evaluate the performance impact and necessity of the statement-level fault location information in the function-level APR. We utilize the ground-truth statement-level fault location information following previous work [62] by labeling the corresponding buggy line with /*bug is here*/. Specifically, the ground-truth fault locations are provided by the official Defects4J GitHub Repository [12]. To investigate the impact of the statement-level fault location information on the function-level APR, we calculate the average number of plausible fixes generated by various models across different auxiliary repair-relevant information setups. private boolean inferTemplatedTypesForCall(\u2026) { \u2026 Map<TemplateType, JSType> inferred = /* bug is here */ inferTemplateTypesFromParameters(fnType, n); /* bug is here */ + Map<TemplateType, JSType> inferred = Maps.filterKeys(\u2026); TemplateTypeReplacer replacer = \u2026 return replacer.madeChanges; } Figure 7: Statement-level fault location information misleads LLM, preventing the repair of the Closure-112 bug From Table 5, we can observe that while applying the statementlevel fault location information enhances the repair performance, the extent of this improvement can be potentially compromised with the token number increase of the auxiliary repair-relevant information. For instance, while K0(Basic)\ud835\udc39\ud835\udc3fachieves a performance improvement of 20.6% compared to K0(Basic), such an improvement shrinks to 6.6% comparing BR(ALL)\ud835\udc39\ud835\udc3fto BR(ALL) with averagely 246 tokens and 7.1% comparing PI(ALL)\ud835\udc39\ud835\udc3fto PI(ALL) with averagely 396 tokens. Moreover, we find that 14 bugs that are originally fixable without fault location information cannot be plausibly fixed across all setups and models when using fault location information. For instance in the Closure-112 bug [10] shown in Figure 6b which demands multiple edits, a correct fix is achieved if the model reads the entire method, thus comprehending the necessity of adding Maps.filterKeys to check if each key (of the TemplateType type) exists in the key collection. However, with the fault location information, the attention of the model becomes disturbed, consequently over-focusing on the Map<TemplateType, JSType> inferred code block and making extensive but ineffective modifications. Finding 6: The statement-level fault location information effectively enhances the repair performance. As the token number of auxiliary repair-relevant information increases, the extent of the improvement can be potentially compromised. 4 DISCUSSION 4.1 Bug report While the bug reports associated with carefully evaluated projects like Defects4J are generally of high quality where their effectiveness can be shown in our evaluation results, they nonetheless include instances of inaccuracies [46]. Specifically, real-world bug reporting is filled with a significant volume of reports that are invalid, irreproducible, incomplete, or outright misleading [22, 25, 51]. Moreover, the process of generating bug reports is manual and labor-intensive, in contrast to the APR techniques seeking to rectify software bugs autonomously, eliminating the need for human intervention [36]. Consequently, relying on bug reports for providing auxiliary repairrelevant information to advance the function-level APR may be inappropriate and impractical, especially when dealing with unknown faults. On the contrary, trigger tests [53, 80, 81] precisely identify the root cause of faults. Error messages [59, 81] can be automatically obtained from test outputs and reveal the fault-triggering boundary conditions. Comments provide function descriptions added by developers [62]. These sources of information are more precise and cost-efficient compared to bug reports. Therefore, we recommend the utilization of project-specific information in LLM-based APR techniques to further improve repair performance. \fConference\u201917, July 2017, Washington, DC, USA Jiahong Xiang, Xiaoyang Xu, Fanchu Kong, Mingyuan Wu, Haotian Zhang, and Yuqun Zhang Comment\u2028 Buggy Code Repair Suggestion Model GPT Trigger Test Error Message CoT Repair Suggestion 1 Repair Suggestions Repair Suggestion 2 Repair Suggestion 3 \u2026 Patch Generation Model Magicoder \ud83c\udfa9 // Provide a fix \u2026 {Repair Suggestion}\u2028 // Buggy Function {Buggy Code} // Fixed Function Fixed Function Fixed Function Fixed Function \u2026 Figure 8: The SRepair framework 4.2 Models for APR Although the CodeLlama models have gained a number of plausible fixes in our study, we do observe abnormal behaviors of CodeLlama-based models in the patch generation of the function-level APR. When applied to the Java-based Defects4J dataset, CodeLlama models frequently generate patches with \u2018[PYTHON]\u2019 tags and Python code, e.g., producing 188,113 such patches in the CodeLlama 34B model. This issue was not prevalent in other models. Hence, we advocate using the high-performing GPT-3.5-Turbo and the open-source Magicoder models, both of which have shown superior capabilities in the APR task. 5 APPROACH By far, we have demonstrated the power of adopting the auxiliary repair-relevant information in the function-level LLM-based APR, i.e., including such information in the repair prompt along with the buggy function under zero-shot learning. In this section, to further leverage the potential of the auxiliary repair-relevant information, we construct a novel function-level APR technique SRepair (referring to Suggestion Repair), which adopts a dual-LLM framework for advancing the repair performance. 5.1 SRepair Framework Our Dual-LLM framework is shown in Figure 8 where SRepair first adopts a repair suggestion model which utilizes the learning power of LLM by comprehensively analyzing the auxiliary repair-relevant information via the Chain of Thought (CoT) technique [72]. Then it provides repair suggestions in natural language. Next, SRepair adopts a patch generation model which exhibits its code generation capabilities by generating the entire patched function following the repair suggestions. More specifically, we enable the CoT technique by prompting the LLM to first analyze the buggy function and project-specific information, then identify the root cause of the bug, and finally generate repair suggestions in natural language. For instance, as shown in Figure 9, the repair suggestion model first identifies the root cause of the Cli-26 bug [9]: \u2018are not being reset after creating an Option\u2019, and then generates the correct repair suggestion, \u2018use a try-finally block\u2019. Finally, such a suggestion is fed to the patch generation model for generating the patched functions. 5.2 Evaluation 5.2.1 Dataset. We use the widely studied repair benchmark of Defects4J [41] and QuixBugs [50]. Specifically, to extensively leverage SRepair\u2019s ability in the function-level APR, we include all functionlevel bugs from Defects4J 1.2 and 2.0, thereby forming a dataset Table 6: Statistics of SRepair Dataset Dataset Project # Bugs SF Bugs MF Bugs Defects4j 1.2 Chart 25 16 9 Closure 140 105 35 Lang 56 42 14 Math 102 74 28 Mockito 30 24 6 Time 22 16 6 Defects4j 2.0 Cli 30 28 2 Codec 13 11 2 Collections 2 1 1 Compress 40 36 4 Csv 13 12 1 Gson 12 9 3 JacksonCore 18 13 5 JacksonDatabind 85 67 18 JacksonXml 5 5 0 Jsoup 58 53 5 JxPath 14 10 4 Overall 665 522 143 that comprises 522 single-function (SF) bugs and an additional 143 multi-function (MF) bugs, i.e., the bugs existing in multiple functions and requiring simultaneous edits on them for a fix, as shown in Table 6. Additionally, we also evaluate on the QuixBugs dataset which is made up of 40 function-level buggy and fixed versions of classic programming problems in both Python and Java. CoT Prompt Input Analyze the buggy code, trigger test and error message Then analyze the root cause Finally, try to provide repair suggestions Comment\u2028 Buggy Code Trigger Test Error Message Root Cause: The OptionBuilder properties are not  being reset after creating an Option Repair Suggestions Suggestion: Use a try-finally block to ensure  OptionBuilder properties are reset Figure 9: Chain of Thought example of Cli-26 Bug \fHow Far Can We Go with Practical Function-Level Program Repair? Conference\u201917, July 2017, Washington, DC, USA Table 7: Single-function APR result of SRepair Datasets Project Plausible Fixes Correct Fixes PI(ALL) SRepair Variant AlphaRepair Repilot FitRepair ChatRepair SRepair500 GPT-3.5-Turbo Magicoder SRepair2\ud835\udc40 SRepair2\ud835\udc40+\ud835\udc39\ud835\udc3f SRepair200 SRepair500 Defects4J1.2 Chart 12 11 14 14 14 14 9 6 8 15 13 Closure 40 30 39 49 48 56 23 22 29 37 47 Lang 19 25 27 29 29 32 13 15 19 21 26 Math 48 43 50 48 47 55 21 21 24 32 42 Mockito 8 8 12 9 12 12 5 0 6 6 11 Time 7 5 5 6 6 7 3 2 3 3 7 Defects4J2.0 Cli 16 13 16 17 17 19 5 6 6 5 18 Codec 8 5 8 8 8 11 6 6 5 8 11 Collections 0 1 0 1 1 1 0 1 1 0 1 Compress 21 22 21 24 26 28 1 3 2 2 21 Csv 10 9 10 9 10 11 1 3 2 3 11 Gson 6 8 7 7 7 9 2 1 1 3 8 JacksonCore 9 6 9 7 9 10 3 3 3 3 10 JacksonDatabind 30 28 39 38 39 45 8 8 10 9 33 JacksonXml 3 1 1 3 1 3 0 0 0 1 2 Jsoup 34 35 33 35 35 39 9 18 13 14 35 JxPath 2 4 4 5 4 5 1 1 1 0 4 D4J 1.2 Total 134 122 147 155 156 176 74 66 89 114 146 D4J 2.0 Total 139 132 148 154 157 181 36 50 44 48 154 Overall 273 254 295 309 313 357 110 116 133 162 300 5.2.2 Implementation. In the SRepair implementation, GPT-3.5Turbo acts as the repair suggestion model due to its superior analytical, coding, and natural language generation abilities, especially in PI(ALL). Magicoder is adopted as the patch generation model due to its cost-effectiveness and competent code generation ability. Notably, for each repair suggestion, SRepair generates 5 patched functions via the patch generation model. We set the sample size of SRepair 200 (denoted as SRepair200) for comparing with previous APR results in our study section and 500 (denoted as SRepair500) for fair comparisons with previous APR techniques [56, 74, 75, 77]. Similar to prior work [39, 49, 77], we additionally add an end-to-end time limit of 5 hours to fix one bug. Moreover, to better repair the Python bugs in QuixBugs, we replace the Java comment symbol \u2018//\u2019 in the input APR prompt with the Python comment symbol \u2018#\u2019. It should be noted that SRepair does not require statement-level fault location information. For the rest setups, we follow our study section. Due to the page limit, we show the experimental results under different configurations and costs of SRepair in our GitHub page [1]. 5.2.3 Evaluation Metrics. Following our study section, we utilize plausible patches to reflect the repair performance. Furthermore, following standard practices in the APR research, we manually inspect each plausible patch for semantic equivalency [54, 56, 58, 76, 77] to determine the correct patches. Due to the intensive manual efforts involved in patch inspection, we conduct a cross-validation with three authors in order to filter out the correct patches generated by SRepair500. 5.2.4 Compared Techniques. We adopt four recent SOTA LLMbased APR techniques: AlphaRepair [77], Repilot [74], FitRepair [75], and ChatRepair [79]. We also adopt GPT-3.5-TurboPI(ALL) and MagicoderPI(ALL) as baselines with the same auxiliary repair-relevant information and models used in SRepair for studying the effectiveness of our Dual-LLM CoT framework. We also form two SRepair200 variants: SRepair2\ud835\udc40with Dual-LLM only, i.e., directly generating Table 8: Correct fixes on QuixBugs datasets QuixBugs SRepair500 SRepair200 ChatRepair AlphaRepair Python 40 40 40 27 Java 40 40 40 28 128 SRepair500 Repilot FitRepair ChatRepair AlphaRepair (a) Single-function dataset 35 SRepair500 Repilot FitRepair ChatRepair AlphaRepair (b) Studied baselines dataset Figure 10: Bug fixes Venn diagram of SRepair500 with studied baselines repair suggestions without CoT, and SRepair2\ud835\udc40+\ud835\udc39\ud835\udc3fwith additional statement-level fault location information for comparison. 5.2.5 Result analysis. Table 7 presents the APR results for singlefunction bugs in the Defects4J dataset. Surprisingly, we find that SRepair500 outperforms all previous LLM-based APR techniques by at least 85%. Specifically, we can observe that 68.4% of singlefunction bugs (357) in Defects4J can be plausibly fixed, and even 57.5% of bugs (300) can be correctly fixed by SRepair500. Such surprising results indicate that SRepair is capable of fixing a significant number of real-world complicated bugs in the function-level APR. Notably, repairing 300 single-function bugs with SRepair costs only $8.6, averaging $0.029 per correct fix, demonstrating its efficiency as an LLM-based APR technique. \fConference\u201917, July 2017, Washington, DC, USA Jiahong Xiang, Xiaoyang Xu, Fanchu Kong, Mingyuan Wu, Haotian Zhang, and Yuqun Zhang Moreover, as in Figure 10a, SRepair500 correctly fixes 128 out of 522 single-function bugs which cannot be fixed by any of the baseline LLM-based APR techniques adopted in this paper. Interestingly, Figure 10b shows that SRepair500 also significantly outperforms the state-of-the-art APR baselines, correctly fixing 35 unique bugs that all other baselines failed to fix in their studied bugs. Such a result indicates that SRepair not only expands the repair task scope to the more practical function-level APR but also achieves remarkable repair performance without the need for statement-level fault location information. Table 8 shows that SRepair500 successfully fixes all bugs in the QuixBugs dataset, indicating its superior capability for diverse programming languages. 0 15 30 45 60 Srepair Srepair GPT-Turbo-3.5 Magicoder 11 15 25 32 17 23 42 53 Plausible Correct # Fixed Bugs 500 PI(ALL) PI(ALL) 200 Figure 11: The APR results of the multi-function bugs in the Defects4J dataset We also evaluate how SRepair repairs complicated multi-function bugs shown in Figure 11 where we find that SRepair500 (53 plausible fixes and 32 correct fixes) and SRepair200 (42 plausible fixes and 25 correct fixes) both largely outperform GPT-3.5-TurboPI(ALL) and MagicoderPI(ALL). Interestingly, as shown in Figure 12 where Functions 1 and 2 require information from successfully running Function 3 to determine if they should execute subsequent statements. This poses a significant challenge for APR techniques, as they need to simultaneously alter the return type of Function 3 to boolean and adapt the function calls in Functions 1 and 2. SRepair successfully identifies such a complex function call and generates the correct fix, indicating the power of SRepair on complicated multi-function faults, which, to our best knowledge, is the first time achieved by any APR technique ever. We further find that SRepair2\ud835\udc40outperforms both GPT-3.5-TurboPI(ALL) and MagicoderPI(ALL) by 8.1% and 16.1% in terms of the number of plausible fixes respectively. Furthermore, leveraging CoT technique achieves even better result (313 plausible fixes) than incorporating public void addPropertyCreator(\u2026) { verifyNonDup(\u2026); \u2026 } protected void verifyNonDup(\u2026) { \u2026 if (!explicit) { return; }\u2026 } public void addPropertyCreator(\u2026) { + if (verifyNonDup(\u2026)){ \u2026 + } } + protected boolean verifyNonDup(\u2026) { \u2026 if (!explicit) { +         return false; } \u2026 + return true; } Function 3 (verifyNonDup) Function 2 (addPropertyCreator) Function 1 (addDelegatingCreator) public void addDelegatingCreator(\u2026) {\u2026 + if (verifyNonDup(\u2026)){ _arrayDelegateArgs = injectables; + } \u2026 } public void addDelegatingCreator(\u2026) {\u2026 verifyNonDup(\u2026); _arrayDelegateArgs = injectables; \u2026 } Figure 12: The multi-function bug JacksonDatabind-69 [13] statement-level fault localization information (309 plausible fixes). Such results indicate the effectiveness of our Dual-LLM framework and CoT mechanism in SRepair. 6 THREATS TO VALIDITY Threats to internal validity. One potential threat arises from our manual validation process, which differentiates between plausible patches and those that are semantically correct. To address this concern, three authors cross-validated the plausible patches of SRepair500 by comparing them to those created by developers (the plausible patches generated by other techniques are mostly subsets). Another threat is the potential for data leakage if the developer patches were included in the original training data. To address this, we examined all the patches generated in our study and by SRepair500 in the Defects4J dataset. Among the total plausible patches produced in our study, only 7.4\u2030 are identical to the developer patches. Similarly, for the plausible patches generated by SRepair500, only 1.5\u2030 match the developer patches. Such overlapped patches pose almost no impact on our experimental results. An additional threat lies in the trigger tests adopted in SRepair where the LLMs might have recognized the trigger tests and manipulated them to pass all tests, creating seemingly plausible patches. Our SRepair\u2019s Dual-LLM mechanism effectively mitigates this threat, as the repair suggestion model only suggests bug fixes without trigger test information, keeping the patch generation model isolated from such data. Threats to external validity. The main threat to external validity lies in our evaluation datasets used which may not well generalize our experimental results. To mitigate this, we evaluate our approach on both the popular Defects4J 1.2 and 2.0 datasets where we include all their single-function bugs in our study. Furthermore, we extend our investigation to multi-function bugs in our SRepair evaluation. We also evaluate SRepair on the QuixBugs datasets, which contain both Java and Python bugs, to validate its generalizability. Threats to construct validity. The threat to construct validity mainly lies in the metrics used. To mitigate this, we adopt the widely-used plausible patches along with their distributions. We also use correct fix to evaluate our approach SRepair. 7 CONCLUSION In this paper, we conduct the first comprehensive study on the function-level LLM-based APR. Our study reveals that LLMs with zero-shot learning are powerful function-level APR techniques. Moreover, directly applying the auxiliary repair-relevant information to LLMs significantly increases the function-level repair performance. Inspired by our findings, we design a Dual-LLM framework utilizing Chain of Thought technique, named SRepair, which achieves remarkable repair performance by correctly fixing 300 single-function bugs in the Defects4J dataset, surpassing ChatRepair [79] by 85% and Repilot [74] by 1.59\u00d7. Notably, SRepair successfully fixes 32 multi-function bugs, which is the first time achieved by any APR technique ever to our best knowledge. DATA AVAILABILITY The data and code are available at GitHub [1] for public evaluation. \fHow Far Can We Go with Practical Function-Level Program Repair? Conference\u201917, July 2017, Washington, DC, USA"
+        },
+        {
+            "url": "http://arxiv.org/abs/2404.12938v1",
+            "title": "MAiDE-up: Multilingual Deception Detection of GPT-generated Hotel Reviews",
+            "abstract": "Deceptive reviews are becoming increasingly common, especially given the\nincrease in performance and the prevalence of LLMs. While work to date has\naddressed the development of models to differentiate between truthful and\ndeceptive human reviews, much less is known about the distinction between real\nreviews and AI-authored fake reviews. Moreover, most of the research so far has\nfocused primarily on English, with very little work dedicated to other\nlanguages. In this paper, we compile and make publicly available the MAiDE-up\ndataset, consisting of 10,000 real and 10,000 AI-generated fake hotel reviews,\nbalanced across ten languages. Using this dataset, we conduct extensive\nlinguistic analyses to (1) compare the AI fake hotel reviews to real hotel\nreviews, and (2) identify the factors that influence the deception detection\nmodel performance. We explore the effectiveness of several models for deception\ndetection in hotel reviews across three main dimensions: sentiment, location,\nand language. We find that these dimensions influence how well we can detect\nAI-generated fake reviews.",
+            "authors": "Oana Ignat, Xiaomeng Xu, Rada Mihalcea",
+            "published": "2024-04-19",
+            "updated": "2024-04-19",
+            "primary_cat": "cs.CL",
+            "cats": [
+                "cs.CL",
+                "cs.AI"
+            ],
+            "label": "Original Paper",
+            "paper_cat": "LLM Fairness",
+            "gt": "MAiDE-up: Multilingual Deception Detection of GPT-generated Hotel Reviews",
+            "main_content": "Introduction Recent advancements in Natural Language Generation (NLG) technology have greatly improved the quality of LLM-generated text. One notable example is OpenAI\u2019s ChatGPT, which has demonstrated exceptional performance in tasks such as story generation (Yuan et al., 2022), question answering (Bahak et al., 2023), essay writing (Stokel-Walker, 2022), and coding (Becker et al., 2023). However, this newfound ability to produce highly efficient, human-like texts also raises concerns about detecting and preventing the misuse of LLMs (Pagnoni et al., 2022; Mirsky et al., 2023). One particular problem is the prevalence of AIgenerated reviews, and while tools and datasets *Oana Ignat and Xiaomeng Xu contributed equally to the manuscript have been proposed, none have solved the problem completely (Wu et al., 2023b), which in turn, leads to the erosion of trust in online opinions. Furthermore, most of the research so far has focused primarily on English, with very little work dedicated to other languages. Our study aims to fill in these gaps and provide novel insights into multilingual LLM-generated hotel reviews. We analyze different types of human-interpretable features, such as linguistic style, writing structure, topics, and psycholinguistic markers, along with baselines across multiple models. We hope our research will help organizations leverage NLP to combat the use of LLMs in scenarios where genuine, human-generated content is highly valued, such as customer reviews on platforms like Booking, Yelp, and Amazon. Specifically, our paper aims to answer two main research questions. RQ1: How LLM-generated multilingual hotel reviews compare to real reviews across syntactic and lexical elements. RQ2: Which factors influence multilingual deception detection performance? The paper makes the following contributions. First, we compile and share a multilingual dataset of 10,000 real and 10,000 AI-generated fake hotel reviews, balanced across ten languages: Chinese, English, French, German, Italian, Korean, Romanian, Russian, Spanish, and Turkish, as well as across ten locations and different sentiment polarities. To the best of our knowledge, this is the first dataset of multilingual reviews at this scale. Second, using this dataset, we conduct extensive linguistic style and lexical analyses to compare the AI-generated deceptive hotel reviews with the real human-written hotel reviews. Finally, we explore the effectiveness of different models for multilingual deception detection in arXiv:2404.12938v1  [cs.CL]  19 Apr 2024 \fhotel reviews across three dimensions: sentiment, location, and language. 2 Related Work LLM-generated Text Detection. The powerful generation capabilities of LLMs has made it challenging for humans to differentiate between LLMgenerated and human-written texts (Jakesch et al., 2023). This led to extensive research being conducted on developing models for detecting LLMgenerated text, including fine-tuned LMs (Jawahar et al., 2020; Guo et al., 2023), zero-shot methods (Solaiman et al., 2019; Ippolito et al., 2019), watermarking techniques (Kirchenbauer et al., 2023a,b), adversarial learning methods (Hu et al., 2023; Koike et al., 2024), LLMs as detectors (Bhattacharjee and Liu, 2024; Yu et al., 2023), and human-assisted methods (Dou et al., 2021). Fine-tuning LMs, in particular Roberta (Liu et al., 2019), has had great success in binary classification settings (Fagni et al., 2021; Radford et al., 2019), and therefore, we also adopt it in our work. On average, these models yielded a 95% accuracy, outperforming zero-shot, and watermarking methods and showing resilience to various attacks within in-domain settings. However, just like other encoder-based fine-tuning approaches, these models lack robustness when dealing with cross-domain or unforeseen data (Bakhtin et al., 2019; Antoun et al., 2023). Our work falls under the category of black-box modeling, as described in a recent survey of AI language detectors by Tang et al. (2023). We are interested in the outputs of LLMs, rather than the specific details of a model\u2019s contents or design. This approach allows us to focus on the differences between human and AI-generated texts, instead of the particular implementation details of models or detectors. Human vs. LLM-generated Text. There have been several efforts to study the differences between AI and human-generated text (Giorgi et al., 2023; Sadasivan et al., 2023; Jakesch et al., 2023; Markowitz et al., 2024; Markowitz and Hancock, 2024) In the context of deception, Giorgi et al. (2023) and Markowitz and Hancock (2024) argue that AI-generated text is inherently deceptive when describing human experiences like writing reviews because the system is not grounded in material world experiences. At the same time, Giorgi et al. (2023) and Markowitz and Hancock (2024) are the closest to our work. They use ChatGPT to generate hotel reviews and compare them to human-written deceptive and truthful hotel reviews from TripAdvisor. This data is collected by Ott et al. (2011) from 20 hotels in Chicago, IL, USA. Markowitz and Hancock (2024) find that AI-generated text has a more analytic style and is more affective, more descriptive, and less readable than human-written text, while Giorgi et al. (2023) find that humanwritten text is more diverse in its expressions of personality than AI-generated text. We replicate their style analysis findings and extend the data collection and analysis to nine other languages and ten global hotel locations. Unlike prior work, we do not analyze deceptive human reviews. In addition, we also analyze the role of sentiment, language, and location in deception performance and implicitly in the quality of the AI-generated reviews. Multilingual LLM-generated Text Detection. While several multilingual models (Tulchinskii et al., 2024; Mitchell et al., 2023; Antoun et al., 2023; Guo et al., 2023) and datasets (Wang et al., 2023; Guo et al., 2020) have been proposed, Wu et al. (2023a), in their comprehensive survey on LLM-generated text, address the need for multilingual datasets and models to facilitate the evaluation of text detectors generated by LLMs across different languages. Addressing them is essential for the usability and fairness of detectors for LLMgenerated text. In our work, we address this gap, by providing a dataset, analysis, and classification models for 10 languages. 3 The MAIDE-UP Dataset To answer our research questions, we compile a novel dataset, which we refer to as MAIDE-UP Multilingual Ai-generateD fakE reviews. MAIDEUP contains a total of 20,000 hotel reviews: 10,000 are real, human-written, and 10,000 are fake, LLMgenerated. The reviews are balanced across language, location, and sentiment. We outline our process for collecting both real and fake reviews below. 3.1 Real Hotel Reviews We collect 10,000 hotel reviews from Booking.com, 1 which is one of the largest marketplaces for online travel bookings. The data is balanced per language, 1booking.com \flocation, and sentiment. Finally, we ensure data quality through automatic and manual assessments. Languages. The dataset is balanced across ten languages: Chinese, English, French, German, Italian, Korean, Romanian, Russian, Spanish, and Turkish. We automatically web-crawl Booking.com for each of the ten languages. Additional details on how we automate this process can be found in Appendix A.1. Locations. We collect reviews from hotels located in popular capital cities: Ankara, Beijing, Berlin, Bucharest, Madrid, New Delhi, Paris, Rome, Seoul, and Washington. Most of the cities are selected to be the capitals of the countries with the official language as one of the 10 languages. The only exception is the New Delhi Russian pair, as hotel reviews in Moscow are restricted, and most hotel reviews in Hindi are written in English. To ensure the collection of an equal number of reviews for each language, particularly for Chinese, Korean, Romanian, and Turkish, where the number of reviews per hotel is often limited, we identify 250 hotels in each city and collect up to 50 reviews per hotel. Figure 1: An example of an English positive review, rated with a score of 10, that contains both \u201cupside\u201d and \u201cdownside\u201d sections. The reviewer can choose to write in just one or both sections. Sentiment. The Booking.com platform provides review scores from 1 to 10, where a score of 1-6 represents a negative review and 7-10 is a positive review. We collect a balanced number of positive and negative reviews for each language, i.e., 500 positive and 500 negative for each language. The platform provides a specific review format consisting of two parts, upside and downside, to allow users to separate their positive and negative feedback. The \u201cupside\u201d and \u201cdownside\u201d sections are optional, as the reviewer can write in just one or both sections. Figure 1, shows a review example of a positive review, rated with a score of 10, that contains both \u201cupside\u201d and \u201cdownside\u201d sections. Quality Assurance. We automatically verify each review\u2019s language and filter out reviews in a different language than the one crawled for (more information in the Appendix). To further ensure the data quality, ten native speakers manually verified 50 random reviews each. Specifically, they verified the review\u2019s syntax and semantics and ensure the sentiment aligns with the content for the \u201cupside\u201d and \u201cdownside\u201d parts of the review, as well as for the review overall. One potential concern is the possibility of fake human-written reviews. Booking.com addresses this by combining specialized personnel and automated systems to detect and remove fake reviews(more information in Appendix A.1). 3.2 LLM-generated Hotel Reviews We generate 10,000 hotel reviews with GPT-4.2 The generated reviews follow the same distribution across language, location, and sentiment, as the real hotel reviews, as described in section 3.1. We use GPT-4 because it is one of the largest LLMs available and has been demonstrated to effectively emulate human texts (Achiam et al., 2023). 3.2.1 Prompt Design and Robustness GPT-4 takes a prompt as input, which is comprised of a list of message objects, and returns one generated hotel review as output. We use messages, which are more interactive and dynamic compared to the classical prompt-style. Specifically, we use messages with two properties: role and content: the role takes one of three values: \u201csystem\u201d, \u201cuser\u201d or \u201cassistant\u201d, while the content contains the text of the message.3 The prompt is first formatted with a \u201csystem message\u201d role, which sets the behavior of the model. This is followed by two rounds of conversations between the roles of \u201cassistant\u201d and \u201cuser\u201d in a few-shot prompting technique. Finally, we use a \u201cuser message\u201d to prompt the model to generate a hotel review in a specified language, location (hotel name and capital city), and sentiment. System Prompt. We find that we can obtain highquality responses with additional context in our 2https://platform.openai.com/ docs/guides/text-generation/ chat-completions-api 3https://help.openai.com/en/articles/ 7042661-chatgpt-api-transition-guide \fprompts. Therefore, we instruct the model to be a well-traveled native {language} tourist in the \"system message\". The {language} placeholder is replaced by the language name of the hotel reviews we aim to collect. The instructions also contain information about the language, location (hotel name and city) and the sentiment of the review, as well as the output format, as illustrated below: You are a well-traveled native {language} tourist, working on writing hotel reviews of hotels you have stayed in. Given hotel name, city name, language, and sentiment, you write a hotel review comprised of upside and downside. Then you give an overall review score, an integer ranging from 1 to 10 where the score larger than 6 indicates positive experience, otherwise negative experience. You always output a JSON containing the following keys: \u201cUpside_Review\u201d, \u201cDownside_Review\u201d, \u201cReview_Score\u201d. Reviews you write are always in consistent styles, tone, sentence structure. User Prompt. To increase the diversity and robustness of the generated data, we collect 36 multilingual \u201cuser messages\u201d. Specifically, we ask ten native speakers to each write four \u201cuser messages\u201d: two in their own language and two in the corresponding English translation. The guidelines given to the annotators are shown in Appendix A.2. We use the \u201cuser messages\u201d to prompt GPT-4 to generate a hotel review with a specified language, hotel location, and sentiment. Below is an example of a \u201cuser message\u201d in Spanish and its English translation. We show all the \u201cuser messages\u201d in the Appendix Table 5. \u00bfPod\u00e9s escribir un comentario positivo en L sobre el hotel H de C? Can you please write a positive review in L for the hotel H located in C? Few-shot prompting. We use the conversations between \u201cuser\" and \u201cassistant\u201d when generating data. The \u201cuser messages\u201d are randomly selected from our multilingual \u201cuser messages\u201d and the \u201cassistant messages\" are randomly extracted from our collected real hotel reviews. The answer to the last \u201cuser message\u201d is automatically generated by the \u201cassistant message\u201d and used to collect the GPT-4 generated hotel reviews. Quality Assurance. To ensure the quality of our generated data, we conduct sanity checks by asking native speakers to review approximately 100 hotel reviews in their respective languages. The reviews are checked for readability, syntax errors, and style. Based on the feedback, we find that some of the generated Chinese reviews contain nonsensical phrases. Additionally, reviews in other languages such as Romanian, Korean, and Spanish have a formal tone. Table 1 displays random reviews in English, both real and generated, with positive and negative sentiments. Reviews sampled from all ten languages are shown in Appendix Tables 6 and 7. Real Hotel Reviews + Nicely furnished room and nicely decorated lobby. Room service is affordable and the receptionists, especially Mr. Omar, are usually eager to help with any queries; N/A The location was very central and the staff was nice and helped us.; The room smelled like cigarettes and there was mold in the bathroom LLM-generated Hotel Reviews + The staff was extremely helpful and accommodating. Clean and well-furnished rooms. Central location with easy access to public transport.; The breakfast offerings could be more varied. Nothing. Horrible experience.; Bad customer service, rooms were not clean and the food was below average. Table 1: Random review samples with positive (+) and negative (-) sentiments in English. Each review has two parts: \u201cupside\u201d and \u201cdownside\u201d, which are separated by \u201c;\u201d. We manually find that it is very challenging for humans to distinguish between real and generated reviews. 4 Multilingual Analyses of Real and LLM-generated Hotel Reviews Using our dataset, we conduct extensive linguistic analysis to compare the AI-generated fake hotel reviews with the real human-written hotel reviews. Analytic writing index measures the complexity and sophistication of the writing, which can be an indicator of advanced thinking. This technique has been used in various fields, including \fpersuasion (Markowitz, 2020), analysis of political speeches (Jordan et al., 2019), and gender studies (Meier et al., 2020), among others. The formula for analytic writing is [articles + prepositions \u2212pronouns \u2212auxiliaryverbs \u2212 adverb\u2212conjunctions\u2212negations] from LIWC scores (Jordan et al., 2019; Pennebaker et al., 2014). We use Linguistic Inquiry and Word Count (LIWC) (Pennebaker et al., 2007, 2015), a goldstandard text analysis tool, to obtain the categories in the index formula for the following languages: Chinese, English, French, and Spanish.4 Since they are translations for different versions of the LIWC lexicon, e.g., 2001, 2007, and 2015, we first align them using the intersection with the 2015 English version. In Table 2, we find that AI-generated texts in English are more complex than real texts, which aligns with our initial observations from data quality checks. The results for Chinese, French, and Spanish are not statistically significant. Descriptiveness can be measured by the frequency of adjectives used in language patterns. Texts with high rates of adjectives tend to be more elaborate and narrative-like compared to texts with low rates of adjectives. (Chung and Pennebaker, 2008) Additionally, adjectives are often used in false speech, making them a key marker of deceitful language (Johnson and Raye, 1981). We measure the ratio of adjectives using the multilingual library textdescriptives from (Hansen et al., 2023).5 For Turkish we use HuggingFace from Altinok (2023).6 We show the results in Table 2. We find that AIgenerated text is usually more descriptive than real text. The only exceptions are German reviews, where the real text is more descriptive, and Korean reviews, where the difference is not significant. Readability considers not only word count, but also word complexity. For instance, longer words are more complex than shorter ones. We use the Flesch Reading Ease metric (Flesch, 1948), which counts the number of words per sentence and syllables per word. This metric is used to assess the structural complexity of language 4While versions for Korean and Turkish are listed as available upon request, we were unable to obtain them. 5https://github.com/HLasse/ TextDescriptives 6https://huggingface.co/ turkish-nlp-suite patterns in various texts, such as scientific articles (Markowitz and Hancock, 2016), online petitions (Markowitz, 2023), and social media data (Hubner and Bond, 2022). We use the multilingual library textdescriptives to compute the Flesch Reading Ease metric and the word count. Results are shown in Table 2. We find that AIgenerated text is usually less readable and more wordy than real text. The only exception is Russian data, where the difference is not significant. Topic Modeling. We compute the most prevalent topics and their keywords with a multilingual pipeline from Scattertext (Kessler, 2017). Each review is processed to obtain the most important words with high TF-IDF scores (Ramos et al., 2003). We pre-process the text with spaCy multilingual pipelines to tokenize hotel reviews and lowercase tokens, remove stop words, and lemmatize tokens.7 We display the topic distribution across real and AI-generated hotel reviews in all languages in Figure 2 and in English in Appendix Figure 9. Comparing real to generated reviews, we find that in multilingual data (Figure 2), the word \u201cBooking\u201d is most frequent in real hotel reviews, along with words like \u201creception (ro: receptie)\u201d, \u201cchecking\u201d, \u201cbathroom (ro: baie, es: bagno)\u201d, \u201cshower\u201d. In contrast, generated hotel reviews contain more words about \u201cservice\u201d, \u201ccomfort (de: komfortabel, ch: \u8212\u9002)\u201d and \u201croom (ro: camerele)\u201d. In English hotel reviews (Figure 9), AI-generated reviews contain more mentions of city names: \u201cBucharest\u201d, \u201cWashington\u201d, \u201cAnkara\u201d, while real hotel reviews contain more words about \u201ccleaning\u201d and \u201ctime\u201d. 5 Multilingual Deception Detection We explore the effectiveness of different models for multilingual deception detection in hotel reviews. As baselines, we test a random classifier, and, as an interpretable model, we train and test a Naive Bayes (Lewis, 1998) classifier. As our main model, we fine-tune an XLM-RoBERTa (Conneau et al., 2019) classifier, which lacks interpretability but is highly performant. 5.1 Baselines Random. The reviews are split equally between real and generated. Therefore, a random baseline would have an accuracy score of 50%. 7https://spacy.io/models \fAnalytic writing Descriptiveness Readability Word Count Lang Real Gen Real Gen Real Gen Real Gen 6.2 \u00b1 7.0 6.5 \u00b1 3.6 2.6 \u00b1 3.9\u2217 4.2 \u00b1 3.5\u2217 62.1 \u00b1 92.9\u2217 79.4 \u00b1 41.2\u2217 11.9 \u00b1 6.8\u2217 18.6 \u00b1 5.2\u2217 13.7 \u00b1 8.6\u2217 15.5 \u00b1 5.5\u2217 66.3 \u00b1 29.0\u2217 54.6 \u00b1 17.1\u2217 49.2 \u00b1 54.7\u2217 55.7 \u00b1 28.5\u2217 21.0 \u00b1 10.1 20.8 \u00b1 6.2 13.9 \u00b1 9.3\u2217 16.2 \u00b1 6.7\u2217 51.3 \u00b1 29.9\u2217 43.9 \u00b1 15.8\u2217 39.6 \u00b1 43.5\u2217 47.5 \u00b124.2\u2217 7.0 \u00b1 7.4\u2217 5.4 \u00b1 5.5\u2217 28.2 \u00b1 32.3 27.2 \u00b1 19.3 41.2 \u00b1 43.0\u2217 47.0 \u00b1 22.4\u2217 15.4 \u00b1 10.2\u2217 19.3 \u00b1 7.6\u2217 -9.4 \u00b1 32.0\u2217 -13.7 \u00b1 17.9\u2217 37.9 \u00b1 41.7\u2217 45.0 \u00b1 23.2\u2217 11.3 \u00b1 9.1\u2217 15.5 \u00b1 6.3\u2217 8.4 \u00b1 36.7\u2217 -0.6 \u00b1 19.3\u2217 39.6 \u00b1 46.3\u2217 44.1 \u00b1 22.1\u2217 6.0 \u00b1 6.4 5.7 \u00b1 4.3 30.1 \u00b1 31.7\u2217 32.6 \u00b1 14.1\u2217 13.7 \u00b1 8.7\u2217 18.9 \u00b1 6.0\u2217 -8.2 \u00b1 35.1\u2217 -16.8 \u00b1 20.0\u2217 42.8 \u00b1 45.5 40.7 \u00b1 20.5 12.9 \u00b1 7.0 15.9 \u00b1 4.1 11.5 \u00b1 8.6\u2217 14.9 \u00b1 5.4\u2217 19.9 \u00b1 27.6\u2217 11.0 \u00b1 17.1\u2217 39.0 \u00b1 40.5\u2217 48.0 \u00b1 23.1\u2217 13.6 \u00b1 9.5\u2217 14.4 \u00b1 6.0\u2217 26.4 \u00b1 25.3\u2217 32.8 \u00b1 14.7\u2217 Table 2: To what degree is AI-generated text different from real text in terms of analytic writing, descriptiveness, readability, and word count? We compute the mean and standard deviation for all the reviews, across each language. We mark (\u2217) when the difference between real and generated data is statistically significant, based on the Student t-test (Student, 1908) with p-value < 0.05. Naive Bayes. As a simple and interpretable baseline, we train a Naive Bayes classifier (Lewis, 1998) to distinguish between real and AI-generated reviews. To tokenize, we use a count vectorizer with a minimum frequency cutoff of 5. We use the Multinomial Naive Bayes model from the sklearn (Pedregosa et al., 2011) library with the default settings. Interpretability results are shown in Appendix B. 5.2 Main Model XLM-RoBERTa. We fine-tune XLM-RoBERTa base (Conneau et al., 2019) model from HuggingFace8. The model is a multilingual version of RoBERTa (Liu et al., 2019), and is pretrained on 2.5TB of filtered CommonCrawl (Wenzek et al., 2020) data containing 100 languages. We use a learning rate of 2e \u22125 and a batch size of 8. We train for 5 epochs and take the best epoch based on validation accuracy. The validation data represents 10% of the train data set. Model Training Setup. We use one model for all the multilingual data and also experiment with different training and test data splits. Specifically, we use a default train-test split of 80-20% and a fewshot train-test split of 1-99%, as shown in Table 3. 6 Evaluation We show the Accuracy and F1 results for all the models in Table 4. The model with the best detec8https://huggingface.co/FacebookAI/ xlm-roberta-base default few-shot real gen real gen Train 8,000 8,000 100 100 Test 2,000 2,000 9,900 9,900 Table 3: Number of reviews for the experimental data split The default split corresponds to an 80-20 % traintest data split. The few-shot split corresponds to a 1-99 % train-test data split. tion performance is XLM-RoBERTa, with an accuracy of 94.9% on the default train-test data split and 76.6% accuracy on the few-shot train-test data split. A fairly high few-shot performance shows that the model is capable of learning this task from very few examples, i.e., 200 reviews balanced across 10 languages. We emphasize the few-shot performance because it closely resembles the real-life scenario when a user wants to generate fake multilingual reviews and has access to very few examples of fake reviews. A zero-shot performance of 50% accuracy indicates that the model had no previous knowledge about this task, and the only knowledge it receives is from our fine-tuning. Finally, we show the accuracy of the main model across multiple testtrain splits in Appendix Figure 8. This shows that the XLM-RoBERTa deception classification model learns considerably from just 2,000 reviews (train data ratio of 10%), and increasing the training data does not lead to high-performance gains. \fFigure 2: Visualization of topics used in the real and LLM-generated reviews across all languages. Points are colored red or blue based on the association of their corresponding topics with AI-generated or real hotel reviews. The most associated topics are listed under Top AI-Generated and Top Real headings. Interactive version: https://anonymous.4open.science/r/hotel_reviews_deception. Setup Accuracy F1 Interpretable Baseline: NAIVE BAYES default 85.9 87.1 few-shot 54.4 54.9 zero-shot 50.0 0.0 Main Model: XLM-ROBERTA default 94.8 94.9 few-shot 76.6 80.1 zero-shot 50.0 0.0 Table 4: Classification test results with the zero-shot, few-shot and default setups. 6.1 Ablation Studies We also compute the XLM-RoBERTa main model few-shot performance across sentiment, review language, prompt language, and hotel location and observe differences in deception performance between different languages and hotel locations, as shown in Figure 3. We use 10-fold cross-validation to compute confidence intervals. We compute the significance using the Student t-test (Student, 1908), with p-value <0.05. Review Language. As shown in Figure 3 (a), deception performance is lowest for Korean and English reviews. This implies that GPT4 is better at generating deceptive, \u201chuman-like\u201d English and Korean reviews. On the other hand, deception performance is highest for German and Romanian reviews, which implies that GPT4 is worse at generating deceptive, \u201chuman-like\u201d German and Romanian reviews. In addition, we find that the GPT4 training language data amount moderately correlates with the GPT4 performance per language. We measure the Pearson correlation coefficient at 0.53. We approximate the amount of training data per language by what is available in CommonCrawl (Wenzek et al., 2020). Prompt Language. From the perspective of a user interested in generating hotel reviews with GPT4, we measure how the language of the user prompt impacts the quality of the generated reviews. As shown in Figure 3 (b), deception performance is lowest for Turkish and Korean, meaning that multilingual reviews generated with prompts in these languages are harder to distinguish from real reviews. Thus, GPT4 is better at generating deceptive \u201chuman-like\u201d multilingual reviews when prompted in Turkish and Korean. On the other hand, deception performance is highest for English and French prompts, thus GPT4 is worse at generating deceptive \u201chuman-like\u201d multilingual reviews when prompted in English and French. \fHotel Location. When generating multilingual hotel reviews using multilingual prompts, we also measure how the location of the hotel impacts the quality of the generated reviews. As shown in Figure 3 (c), deception performance is lowest for Seoul, Rome, and Beijing, meaning that multilingual generated reviews for these hotel locations are harder to distinguish from real reviews. Thus, GPT4 is better at generating deceptive \u201chumanlike\u201d multilingual reviews for hotels in Seoul, Rome, and Beijing. On the other hand, deception performance is highest for Bucharest, Washington, Ankara, and Berlin, thus GPT4 is worse at generating deceptive \u201chuman-like\u201d multilingual reviews for hotels in Bucharest, Washington, Ankara, and Berlin. Review Sentiment. Across sentiment polarities, our main deception classification model obtains an accuracy of 79.9 for positive reviews and 82.6 for negative reviews. The performance difference between the two types of reviews is statistically significant. A lower deception classification performance on positive reviews indicates that GPT4 is better at generating \u201chuman-like\u201d multilingual positive reviews than \u201chuman-like\u201d multilingual negative reviews. Review and Prompt Language. We also compute deception detection accuracy per prompt and review language pair as shown in Figure 4. For each review language, we measure which prompt languages achieve lower deception accuracy, which is equivalent to better, more \u201chuman-like\u201d generation performance. For example, we find that better Chinese reviews are generated using Turkish prompts. Additionally, Korean reviews have the lowest deception performance, independent of language prompts. Therefore, GPT4 is best at generating deceptive, \u201chuman-like\u201d Korean reviews, independent of the prompt language. In contrast, GPT4 is worst at generating deceptive, \u201chuman-like\u201d Turkish reviews, independent of the prompt language. 7 Conclusion In this paper we focused on the identification of AI-written fake hotel reviews in multiple languages. To facilitate research in this domain, we released MAIDE-UP, a dataset of 10,000 real and 10,000 AI-generated fake hotel reviews balanced across ten languages. Using this data, we performed exFigure 3: Accuracy with XLM-RoBERTa model per (a) review language, (b) prompt language, and (c) hotel location on the few-shot train-test split. Chinese English French German Italian Korean Romanian Russian Spanish T urkish Prompt Language Chinese English French German Italian Korean Romanian Russian Spanish T urkish Review Language 80 85 90 95 100 Figure 4: Accuracy with XLM-RoBERTa model per prompt and review language on few-shot train-test split. tensive linguistic data analyses to gain insight into how AI fake hotel reviews differ from real hotel reviews. Finally, we explored the effectiveness of several models for deception detection in hotel reviews across three main dimensions: sentiment, location, and language. Despite the difficulty humans have in distinguishing between real hotel reviews and those generated by LLMs, we discovered that these posts have noticeable differences in style, structure, and semantics and that, even with little data, fine-tuned models accurately detect deceptive reviews across different \flanguages. Our dataset can be used to train and analyze other multilingual models, and it is publicly available at https://github.com/MichiganNLP/ multilingual_reviews_deception. Limitations 1. Multilingual models limitations When analyzing data across ten different languages, we encounter significant challenges in identifying computational models and tools that can be universally applied. In Table 2, we cannot find the LIWC categories required for analytic writing formula for the following languages: German, Italian, Romanian, Korean, Russian, Turkish. Additionally, the textdescriptives library does not currently support readability metrics for Chinese, Korean, and Turkish. This highlights the limitations of computational linguistic methods, which are currently predominantly English-focused. This, in turn, restricts the potential for research on multilingual data. 2. Temporal limitations of LLM-generated data Although LLMs are incredibly powerful in terms of understanding and generating text, they may not fully capture the current cultural and societal context in their outputs. This is because they are trained on data up to a specific cutoff date. For example, GPT-4 was trained on data only up to September 2021, which means that it may not accurately reflect events or changes that have occurred after that date. Ethics Concerns We strongly oppose using our research findings and data to generate multilingual reviews to deceive consumers into believing they are human-authored. These unethical practices compromise the credibility of online review platforms and erode consumer trust. Instead, we advocate for transparency and authenticity in the digital marketplace. We have developed a multilingual deception detection model to combat the proliferation of fake reviews generated by bots. This model employs advanced algorithms to meticulously analyze linguistic nuances and syntactic structures, enabling the accurate differentiation between multilingual reviews created by language models and those written by human users. By providing this tool, we aim to empower businesses and online platforms to maintain ethical standards, protect consumers from deceptive practices, and foster a more trustworthy and reliable digital environment."
+        },
+        {
+            "url": "http://arxiv.org/abs/2404.14897v1",
+            "title": "Beyond the Speculative Game: A Survey of Speculative Execution in Large Language Models",
+            "abstract": "With the increasingly giant scales of (causal) large language models (LLMs),\nthe inference efficiency comes as one of the core concerns along the improved\nperformance. In contrast to the memory footprint, the latency bottleneck seems\nto be of greater importance as there can be billions of requests to a LLM\n(e.g., GPT-4) per day. The bottleneck is mainly due to the autoregressive\ninnateness of LLMs, where tokens can only be generated sequentially during\ndecoding. To alleviate the bottleneck, the idea of speculative execution, which\noriginates from the field of computer architecture, is introduced to LLM\ndecoding in a \\textit{draft-then-verify} style. Under this regime, a sequence\nof tokens will be drafted in a fast pace by utilizing some heuristics, and then\nthe tokens shall be verified in parallel by the LLM. As the costly sequential\ninference is parallelized, LLM decoding speed can be significantly boosted.\nDriven by the success of LLMs in recent couple of years, a growing literature\nin this direction has emerged. Yet, there lacks a position survey to summarize\nthe current landscape and draw a roadmap for future development of this\npromising area. To meet this demand, we present the very first survey paper\nthat reviews and unifies literature of speculative execution in LLMs (e.g.,\nblockwise parallel decoding, speculative decoding, etc.) in a comprehensive\nframework and a systematic taxonomy. Based on the taxonomy, we present a\ncritical review and comparative analysis of the current arts. Finally we\nhighlight various key challenges and future directions to further develop the\narea.",
+            "authors": "Chen Zhang, Zhuorui Liu, Dawei Song",
+            "published": "2024-04-23",
+            "updated": "2024-04-23",
+            "primary_cat": "cs.CL",
+            "cats": [
+                "cs.CL",
+                "cs.AI"
+            ],
+            "label": "Original Paper",
+            "paper_cat": "LLM Fairness",
+            "gt": "Beyond the Speculative Game: A Survey of Speculative Execution in Large Language Models",
+            "main_content": "Introduction In recent one year or two, (causal) large language models (LLMs) have rushed into people\u2019s eyes because of their remarkable performance in terms of reasoning, decision, and so on [Brown et al., 2020; Chowdhery et al., 2023; Touvron et al., 2023]. However, the benefits come with a critical concern. The inference efficiency, especially the inference latency in comparison to the inference memory [Wan et al., 2023], raises anxieties on whether LLMs could be sustainable with respect to billions of requests per day like those submitted to GPT-4 [OpenAI, 2023]. It is commonly recognized that the latency is bottlenecked by the autoregressive nature of LLMs, in which tokens are generated in a one-by-one fashion during decoding. To mitigate the bottleneck, a wide range of methods such as pruning [Ma et al., 2023; Xia et al., 2023b; Sun et al., 2023a], distillation [Tunstall et al., 2023; Zhang et al., 2023a], have been proposed. Among these methods, the idea of speculative execution as in computer architecture [Hennessy and Patterson, 2012] is introduced to LLM decoding in a draftthen-verify style. The regime would speculatively obtain a sequence of tokens via some heuristic techniques and then feed the sequence to the LLM so that the tokens could be verified. Unlike sequential generation, the verification of tokens is parallel, which can significantly lift the decoding speed. Distinguished from other methods to circumvent the bottleneck, this is the unique direction that concentrates on the efficiency improvement in the decoding. Due to this, the direction is orthorgnal to any other directions and can be easily combined with others to achieve more significant gains. While a variety of work has been devoted to optimizing the speculative execution in LLMs (e.g., blockwise parallel decoding that foresees coming tokens in one step with multiple predictive heads [Stern et al., 2018], speculative decoding that formulates a sub-optimal token sequence efficiently with auxiliary small models [Leviathan et al., 2023], etc.), there is a lack of a systematic critical review of this exciting area. To this end, we present the very first survey that reviews and unifies the literature of LLM speculative execution in a comprehensive framework and a systematic taxonomy. Based on the taxonomy, the existing methods in this area are summarized, critically analyzed and compared, unveiling various key challenges that need to be tackled in the future. Correspondingly, we highlight a series of promising directions and opportunities that can be explored to further develop this encouraging yet challenging area.1 The survey is organized as follows: first, we offer an overview of LLM decoding and speculative execution in 1We note that there is a concurrent survey of speculative decoding released right before (Jan. 15th, 2024) our submission at https://arxiv.org/abs/2401.07851, However, it takes a much looser framework than ours. arXiv:2404.14897v1  [cs.CL]  23 Apr 2024 \fAutoregressive M x1 xn xn+1 \u2026 \u2026 \u2026 \u2026 \u2026 xn+j Parallel M x1 xn p\u2019n+1 \u2026 \u2026 \u2026 \u2026 \u2026 p\u2019n+k Speculative M\u2019 x1 xn x\u2019n+1 \u2026 \u2026 \u2026 \u2026 \u2026 x\u2019n+k p\u2019n+k+1 Drafting Verification (a) Autoregressive decoding, where tokens are sequentially decoded. Autoregressive M x1 xn xn+1 \u2026 \u2026 \u2026 \u2026 \u2026 xn+j Parallel M x1 xn p\u2019n+1 \u2026 \u2026 \u2026 \u2026 \u2026 p\u2019n+k Speculative M\u2019 x1 xn x\u2019n+1 \u2026 \u2026 \u2026 \u2026 \u2026 x\u2019n+k p\u2019n+k+1 Drafting Verification (b) Speculative execution, where tokens are speculatively drafted and in parallel verified. Figure 1: An illustration of speculative execution in LLMs via a comparison between autoregressive decoding and speculative execution. LLMs (Section 2), which can be decomposed into the designs of drafting and verification; second, we delve into the design of drafting (Section 3 and design of verification (Section 4) respectively; then, we showcase how to evaluate the LLM speculative execution systems (Section 5) and discuss some well-known implementations and applications (Section 6). Finally, we conclude the key challenges and opportunities of speculative execution in LLMs (Section 7). 2 Speculative Execution in LLMs A critical issue that the causal LLMs are faced with is the latency problem. Owing to the autoregressive nature of LLMs, their decoding can suffer from pretty high latency, making it resource-intensive to handle billions of requests per day. Formally, given a sequence of input tokens I = {xi}n i=1 and a target model M, the autoregressive decoding process can be described as below: xn+j \u223cM(x|x1, . . . , xn, xn+1, . . . , xn+j\u22121) (1) where xn+j is the j-th output token to be decoded. It is the dependency of xn+j to all previous input and already generated tokens that makes the LLM decoding autoregressive, as shown in Figure 1a. Speculative execution is a concept originally proposed in the field of computer architecture [Hennessy and Patterson, 2012]. It is a strategy that fully utilizes spare resources to execute some speculative tasks in advance that may or may not be useful for the upcoming tasks. If the speculatively executed tasks are useful, the execution speed of upcoming tasks would be substantially enhanced. Otherwise, the speed would not be degraded but remain the same as the circumstance that these speculative tasks have never been executed. Inspired by this idea, speculative execution is adapted to LLMs in expectation to speed-up LLM decoding. The adaptation primarily follows a draft-then-verify paradigm. The drafting stage is akin to executing the speculative tasks, and the verification stage is similar to checking the usefulness of the speculative tasks in the upcoming tasks. In the language of LLM decoding, the drafting stage accords with a fast construction of a sequence of tokens, and the verification stage corresponds to a parallel validation of the sequence of tokens. Since there is no obvious spare time in LLM decoding, the drafting stage should be as fast as possible. If the tokens from the drafting stage are of high quality, then the verification stage would benefit from the drafting and be accelerated by the virtue of shifting from the autoregressive decoding to the parallel verification. By notations, the drafting stage can be interpreted as below: x\u2032 n+j \u223cM\u2032(x|x1, . . . , xn, x\u2032 n+1, . . . , x\u2032 n+j\u22121) (2) where M\u2032 is a fast and speculative drafter. There could be multiple drafts rather than only one draft for an improved performance, and these drafts will be appropriately managed. After that, the managed speculative tokens T = {x\u2032 n+j}k j=1 will be verified by the target model (or say verifier) M to determine whether the speculative tokens are useful or not as below: P = {p\u2032 k+1}k+1 j=1 \u223cM(x1, . . . , xn, x\u2032 n+1, . . . , x\u2032 n+k) (3) where P is the speculative probabilities based on the speculative tokens. Then an acceptance criterion will be applied by taking both T and P into considerations to determine whether the speculative tokens are valid or not and yield the final output O. Typically, only part of the speculative tokens are valid. The partly-accepted case is also viewed as a useful speculation. In view of this, a too long or too short speculation may be less useful, as a short speculative output may degenerate \fto autoregressive decoding (e.g., k is 1) and a long speculative output may give diminishing speed-up return yet heavy latency cost. Therefore, commonly a termination criterion will be deployed in the drafting stage for an early stop of the drafter. The above description provides an overview on speculative execution in LLMs, as shown in Figure 1b. Deviated from the overview, we can draw a comprehensive framework, as formulated below: Framework. Given an input I, the drafter M\u2032 drafts one or multiple sequences of managed tokens T in a speculative manner in the drafting stage. Then the verifier based on this further produces a sequence of probabilities P, verifies the usefulness of the speculative tokens, and leads to the final output tokens O in parallel. Proper termination criterion should be settled for the drafter, as is the acceptance criterion for the verifier. Conceptually, Drafting: I \u2192M\u2032 termination \u2212 \u2212 \u2212 \u2212 \u2212 \u2212 \u2192T Verification: I \u25e6T \u2192M \u2192P acceptance \u2212 \u2212 \u2212 \u2212 \u2212 \u2212 \u2192O where \u25e6denotes a combination of the input I and the speculative tokens T. While each involved component in the framework can vary from one to another, the variations can be generally categorized according to the concerned stages. This grants us a chance of setting up a systematic taxonomy of existing literature, as shown in Figure 2. Following this taxonomy, we can organize the existing methods into different categories, which will be detailed in the next sections. 3 Design of Drafting This category mainly involves the design of the drafter, termination criterion, and draft management. The drafter is abstracted as a draft constructer, which serves as the core of the drafting stage. The termination criterion is an indicator of when the drafter should be terminated, or in other words, how the length of the speculative tokens k is chosen. In view that there might be multiple drafts instead of a unique one, the draft management is aimed at organizing these drafts. 3.1 Drafter Generation versus Retrieval To certain degree, the drafter itself is usually a causal language model that generates speculative tokens. The drafter can be an additional small model besides the target model that generates candidate tokens as in speculative decoding [Leviathan et al., 2023] or several lightweight predictive heads attached to the target model that foresee the forthcoming (e.g., next-next) tokens as in blockwise parallel decoding [Stern et al., 2018]. Recent progresses suggest that the drafter can also be a retriever that retrieves tokens from a large corpus that complete the preceding context [He et al., 2023], as indicated in Figure 3a versus 3c. The retriever is not only faster than the small model and the predictive heads, but also promising if the corpus is of high merit (e.g., high quality and relevance). Small Models versus Predictive Heads As mentioned above, the central difference between blockwise parallel decoding and speculative decoding lies in their model usages, as indicated in Figure 3a versus 3b. The speculative decoding requires additional small models that autoregressively draft speculative tokens. These small models are constrained and are thus much more efficient than the target model, so that the speed-ups can cover the costs of them. The construction of the small models can be based on existing models or derived models. It should be highlighted that the small models must have exactly the same vocabularies as the target model, so there could be few existing models that can be directly used in the drafting [Chen et al., 2023a]. This naturally entails the derivation of the small models from the target model via distillation [Zhou et al., 2023], quantization [Miao et al., 2023], layer-skipping [Zhang et al., 2023b], and early-exiting [Hooper et al., 2023], etc. Moreover, the drafting is not limited to only one small model. It is argued that staged or cascaded small models of different scales can further promote the performance, motivated by ensemble learning [Spector and R\u00b4 e, 2023; Chen et al., 2023b]. Staged small models [Spector and R\u00b4 e, 2023] somehow introduce a pre-verification process where the speculative tokens proposed by a smaller model is verified by a slightly larger (but still small compared with the target LLM) model. This process will iterate until all small models are staged through and will produce speculative tokens of higher quality with minor time overhead. On the other hand, cascaded small models [Chen et al., 2023b] posit that the earlier speculative tokens should be harder to draft than the later ones, and thus allocates slightly larger models for the earlier tokens yet smaller models for the later tokens. The blockwise parallel decoding urges lightweight predictive heads to draft speculative tokens in a prophetic manner. While the prediction needs an execution of the target model, multiple tokens instead of one token are produced and the drafting process can be potentially combined with the verification process in one run (i.e., drafting during verification is possible). It is evident that simple duplication and tuning of the original prediction head for language modeling should be already very effective [Cai et al., 2023]. However, latest advances have claimed that more complex head architectures [Li et al., 2023b] are more appealing. Moreover, using only one predictive head that conditions on different looking-ahead tokens to mimic multiple predictive heads is also promising [Monea et al., 2023]. 3.2 Termination Criterion Static Setting As mentioned, either a too short or too long sequence of speculative tokens is sub-optimal. Without specifications on the length, the drafter is not properly regulated. A straightforward solution to this issue is to set the length k to a static value that may be iteratively and manually refined [He et al., 2023]. \fSpeculative Execution in LLMs Design of Verification Acceptace Criterion Typical Acceptance Rejection Sampling Exact Matching Verifier Tree Chain Design of Drafting Draft Management Trie Tree Beam Tree Linear Chain Termination Criterion Heuristic Rule Adaptive Thresholding Static Setting Drafter Retrieval Generation Figure 2: A systematic taxonomy of existing literature of speculative execution in LLMs. Adaptive Thresholding Although static setting can fulfill most use cases, the labor intensity brought by it could also be cumbersome. To address the problem, adaptive thresholding methods have been proposed, aiming to early stop the drafting based on the per-token confidence [Kim et al., 2023]. If the confidence is below a threshold, the drafting will be stopped. The threshold can be adaptively adjusted with respect to some optimization objective (e.g., the drafting quality) [Zhang et al., 2023b]. Heuristic Rules Furthermore, a few heuristic rules can also be engaged in the termination. A typical design is that the length of the speculative tokens will be increased if the previous speculation is fully accepted in the verification, and otherwise it will be decreased [Joao Gante, 2023]. Another approach could be altering the length depending on the batch size from the system serving perspective [Su et al., 2023]. 3.3 Draft Management One Draft versus Multiple Drafts It is identified that bringing only one draft during drafting can inhibit the usefulness of the speculative execution. Thus the use of multiple drafts is also an interesting topic. Consequently, draft management serves as a bridge to organize these drafts and export drafts to the verification stage. There are many ways to generate multiple drafts. For retrieval-based drafters, it is spontaneous to get multiple drafts since the retrieval could always return multiple candidates. For generation-based drafters, the most naive way to come up with multiple drafts is sampling multiple times [Sun et al., 2023b]. Another approach is using multiple heterogeneous small models or predictive heads if available [Miao et al., 2023]. Currently, there is also an outgrowth trend to leverage a beam of top-k tokens to form a tree of candidates [Cai et al., 2023; Yang et al., 2024]. Necessarily, multiple drafts would demand corresponding tactics in the verification stage to import the generated drafts properly, which will be detailed in Section 4.1. 4 Design of Verification This category involves the design of a verifier and an acceptance criterion. The verifier is usually the target model with specifications according to the structure of potentially multiple drafts. The acceptance criterion aims to judge whether or not the drafts should be partly accepted, i.e., whether it is fine that the length of the accepted tokens is smaller than k. 4.1 Verifier Chain versus Tree If only one draft needs to be verified, then a chain-based verifier, which essentially means a common one that takes in tokens as a sequence or a chain, should be fairly enough. Nonetheless if multiple drafts are used, consecutively verifying these drafts one by one would be too time-consuming. Thereby, a tree-based verifier is imposed and this idea is largely shared across literature [Miao et al., 2023; He et al., 2023; Cai et al., 2023]. For example, He et al. [2023] establishes a trie tree from multiple drafts, prunes less frequent nodes from the trie tree, and verifies them at one run with a tree attention (i.e., the child tokens can only see their parent tokens by attention masking), as presented in Figure 4, \fSmall Model x1 xn x\u2019n+1 \u2026 \u2026 \u2026 \u2026 \u2026 x\u2019n+k Target Model Predictive Heads x1 xn \u2026 \u2026 \u2026 x\u2019n+1 \u2026 \u2026 x\u2019n+k Retriever x1 xn \u2026 \u2026 \u2026 x\u2019n+1 \u2026 \u2026 x\u2019n+k x1 xn \u2026 \u2026 \u2026 (a) Speculative execution with a small model, alias speculative decoding. Small Model x1 xn x\u2019n+1 \u2026 \u2026 \u2026 \u2026 \u2026 x\u2019n+k Target Model Predictive Heads x1 xn \u2026 \u2026 \u2026 x\u2019n+1 \u2026 \u2026 x\u2019n+k Retriever x1 xn \u2026 \u2026 \u2026 x\u2019n+1 \u2026 \u2026 x\u2019n+k x1 xn \u2026 \u2026 \u2026 (b) Speculative execution with multiple predictive heads, alias blockwise parallel decoding. gressive M xn Parallel M x1 xn \u2026 \u2026 \u2026 Speculative M\u2019 x1 xn x\u2019n+1 \u2026 \u2026 \u2026 \u2026 \u2026 x\u2019n+k Drafting Verification Small Model x1 xn \u2026 \u2026 \u2026 Ta x1 \u2026 Retriever x1 xn \u2026 \u2026 \u2026 x\u2019n+1 \u2026 \u2026 x\u2019n+k x1 xn \u2026 \u2026 \u2026 (c) Speculative execution with a retriever, alias retrieval-based speculative decoding. Figure 3: The illustration of different categories of the drafter. odel e Heads +1 \u2026 \u2026 x\u2019n+k It I is \u2019 a is \u2019 a Figure 4: The illustration of tree attention. In the tree attention, child tokens can only see their parent tokens, facilitating the parallel verification of potentially multiple drafts. In contrast, one draft would only require a chain attention, which is causal and lower-triangular. 4.2 Acceptance Criterion Exact Matching Once a draft is fed into the target model, we can attain the corresponding output probabilities. By aligning the speculative tokens and the probabilities, we can infer whether each token is valid or not in the draft. The most simple acceptance criterion is exact matching [Joao Gante, 2023], which examines whether a speculative token is correspondingly the one with the maximum probability. Rejection Sampling Although exact matching can guarantee that the verified output shares the same quality with the output of the target model itself at a minor cost, this equality holds only when greedy decoding is used. For cases where sampling decoding is used for the target models, exact matching can hardly accept tokens from the draft, which may result in a slow-down rather than a speed-up of decoding. Hence, an acceptance criterion modified from rejection sampling is proposed to alleviate the issue [Leviathan et al., 2023; Chen et al., 2023a]. In theory, this acceptance criterion can be applied to both greedy decoding and sampling decoding. Yet, if multiple drafts are given, this acceptance criterion can unexpectedly accept a few of them so that we cannot trivially determine which one to use actually. So an optimal transport perspective is studied towards improving the criterion [Sun et al., 2023b]. Typical Acceptance The above-mentioned two acceptance criteria provide rigorous guarantees for quality. However, a too rigorous acceptance criterion can offset the effort of the parallel verification and degrade the speculative execution as a burden, especially when a temperature is applied. Consequently, a moderately relaxed acceptance criterion is needed for more observable speed-up in some scenarios. Typical acceptance takes this role and accepts tokens in the draft if their speculative probabilities go beyond a hard threshold [Cai et al., 2023]. In another perspective [Xia et al., 2023a], the threshold is dynamically adjusted via a top-k constraint. For the case that multiple drafts are offered, typical acceptance will consider the one that forms the longest sequence and drop others. Critically, typical acceptance can lead to unfair comparisons in experiments and should be properly highlighted if used. 5 Evaluation To evaluate the performance of speculative execution in LLMs, a common evaluation measure is the latency per token, which is computed as the elapsed time divided by the number of output tokens. It is formally defined as below: latency = elapsed seconds #generated tokens (4) In some literature, a variant of this measure is used in its reciprocal form, i.e., tokens per second as below: throughput = #generated tokens elapsed seconds (5) After obtaining these measures, the relative speed-up can be viewed as an important comparative measurement between two methods. \fTable 1: The reported speed-ups in comparison with autoregressive decoding from available representative methods. Tran stands for translation task, Summ stands for summarization task, and Inst stands for instruction-following task. Method Drafter Verifier Task Target Model Speed-up Vicuna [2023] \u2013 \u2013 \u2013 \u2013 1.0\u00d7 Blockwise Decoding [2018] predictive heads chain Tran Transformer \u223c3.3\u00d7 SpecInfer [2023] multiple small models tree Inst LLaMA \u223c2.0\u00d7 Medusa [2023] predictive heads tree Inst Vicuna \u223c1.9\u00d7 Eagle [2023b] predictive heads tree Inst Vicuna \u223c3.0\u00d7 SpecDec [2023a] look-ahead tokens chain Tran Transformer \u223c3.0\u00d7 BiLD [2023] small model chain Tran/Summ mT5 \u223c1.6\u00d7 Speculative Decoding [2023] small model chain Tran/Summ T5 \u223c2.5\u00d7 Speculative Sampling [2023a] small model chain Summ/Code Chinchilla \u223c2.2\u00d7 Assisted Generation [2023] small model chain Summ OPT \u223c2.6\u00d7 Staged Speculative [2023] staged small models chain Code GPT-2 \u223c1.6\u00d7 SpecTr [2023b] small model tree Inst PaLM \u223c2.1\u00d7 Self-Speculative [2023b] layer-skipped small model chain Summ/Code LLaMA-2 \u223c1.4\u00d7 DistilSpec [2023] distilled small model chain Inst/Summ/Math GPT-2/T5 \u223c1.3\u00d7 REST [2023] retrieval tree Code/Inst LLaMA/Vicuna \u223c1.9\u00d7 Cascaded Speculative [2023b] cascaded small models chain Inst/Math T5 \u223c3.5\u00d7 MultiCand Speculative [2024] small model tree Inst/Tran LLaMA/Vicuna \u223c2.2\u00d7 PaSS [2023] look-ahead tokens chain Code LLaMA \u223c1.5\u00d7 Commonly used datasets for evaluation range from instruction-following ones like Alpaca [Taori et al., 2023] and MT-Bench [Zheng et al., 2023], to mathematics data such as GSM8K [Cobbe et al., 2021], and coding data like HumanEval [Chen et al., 2021]. Others may include summarization datasets like CNN/DailyMail [See et al., 2017], XSum [Narayan et al., 2018] and translation datasets like WMT. Hereby, we offer an overview of reported performance of the methods that are reviewed in this paper, as a cheatsheet displayed in Table 1. 6 Implementations and Applications There are various implementations of speculative execution in a range of LLM inference frameworks. Likewise, the applications are also not unique. 6.1 Implementations LLaMA.cpp To facilitate the widespread accessibility of Large Language Models (LLMs), we introduce LLaMA.cpp [Gerganov et al., 2023], a robust solution designed to streamline the deployment process. LLaMA.cpp enables the users to efficiently operate an LLM across various platforms, leveraging advanced model compression techniques like quantization. Specifically, LLaMA.cpp features a comprehensive integration of C/C++ implementations devoid of external dependencies. It employs a mixed-precision computation approach, and offers a range of quantization options. Notably, LLaMA.cpp has been adeptly adapted for deployment on Apple silicon. This innovation allows users, even those with limited GPU resources, to run an LLM on their personal computers effectively. In parallel, speculative execution serves as a straightforward yet effective method to reduce inference latency. This library includes various implementations of speculative execution, such as standard speculative decoding and tree-based speculative decoding. We will elucidate these methods in a step-by-step manner. Fundamentally, both approaches adhere to a similar process, encompassing a drafting stage and a verification stage. During the drafting phase, each utilizes a smaller model to generate speculative tokens. The termination criterion is based on adaptive thresholding, i.e., if the probability of the current token falls below that of the subsequent token or an end-of-sentence token is reached. The primary distinction between these methods lies in their draft management and verification mechanisms in the subsequent stage: the tree-based approach employs tree draft management and a tree verifier, whereas the standard method utilizes a linear chain for both management and verification. In terms of acceptance criteria, an exact matching strategy is implemented for both methodologies. vLLM There have been significant efforts to optimize LLM computations beyond traditional deployment methods because of high latency and substantial memory footprint of LLMs. A notable contribution in this area is vLLM [Kwon et al., 2023], a framework designed for fast and cost-effective inference, addressing challenges related to memory utilization and I/O communication bottlenecks. Central to vLLM is the innovative Paged Attention mechanism, which optimizes KV-cache memory use by transforming continuous memory requirements into a discontinuous format, akin to the paged memory systems in operating systems, thereby enhancing overall memory efficiency. A key feature of Paged Attention is its facilitation of efficient memory sharing for parallel sampling, allowing different sequences to map their logical blocks onto the same physical block. In practical deployments, vLLM has demonstrated a remarkable capability, with backend serving throughput reaching up to 30 times higher \fthan that of the traditional HuggingFace backend. Within the vLLM\u2019s speculative execution framework, various strategies are employed at different stages. In the drafting stage, a smaller model is utilized to generate candidate tokens, followed by the application of a static setting to terminate generation. For draft management, a linear chain strategy has been adopted. The verification stage features the use of a chain scheme and rejection sampling method, consistent with the methodologies presented in original research papers [Leviathan et al., 2023; Chen et al., 2023a]. Importantly, these implementations represent just a preliminary foray into the speculative execution capabilities of vLLM, with ongoing development and additional proposals (PRs) for further enhancements in speculative execution within the vLLM framework. LLaMA.cpp is primarily focused on enhancing the accessibility of LLMs, whereas vLLM concentrates on increasing the throughput and reducing the latency of LLMs deployments. With specific regard to speculative execution, LLaMA.cpp offers a more comprehensive implementation compared to that of vLLM at present. 6.2 Applications Online Speculative Decoding It has been observed that constant speculative decoding cannot meet the requirement of continuously changing environment in online services, e.g., queries from users can have diverse topics. This distributional shift at time span can prevent speculative decoding achieving speed-up, and potentially make speculative decoding a burden for serving. Therefore, Liu et al. [2023] proposes to continually updating the small model in the speculative decoding with online data. In doing so, the small model is kept updated with the requirement of the online environment. Contrastive Speculative Decoding Contrastive decoding [Li et al., 2023a] is a technique imposed to boost the generation quality by leveraging the generation probability of a small model as the baseline and contrasting the generation probability of the target model to the baseline. Since problems like hallucination may underlie the probability of the small model, the contrast could result in a better generation quality. Naturally, a combination of contrastive decoding and speculative decoding can be used, as both of them utilize an additional small model besides the target model as in Yuan et al. [2023]. It is reported that by incorporating the small model to the target model, both the generation quality and speed are lifted up by a multiple of around 2. On-device Speculative Decoding Owning to the speed-ups brought by speculative execution in LLMs, it is not surprising that speculative decoding is integrated to on-device scenarios to better play with the limited resources [Xu et al., 2023]. By doing so, LLMs could be executed much faster than ever on mobile devices. 7 Challenges and Opportunities In the above sections we have reviewed the state-of-theart methods and compared the similarities and dissimilarites among them. Based on the observations and discussions, we can now summarize the should-be-highlighted challenges yet to be tackled in the future, whilst the opportunities of exploring possible solutions to these challenges: CP 1: Framework Design Given so many design components to be determined in a speculative execution algorithm, it turns out challenging to customize an optimal framework for speculative execution in a wide range of application scenarios. For example, whether we should use one small model or multiple predictive heads in the drafting is largely variant from one case to another. However, this also offers the opportunity to further optimize and unify currently used frameworks so that the number of such variables would be reduced. This shall spare a lot efforts in finding a design choice for a different task. CP 2: Parameter Search It is identified that there are quite a few parameters to be settled, like the number of speculative tokens and the threshold in typical acceptance. Although various methods have been developed to automatically detect the ideal values of these parameters, it is still hard to tell whether they are good enough. In this demand, we would better establish more robust methods to search and set these parameters so that more stable and appealing performance can be yielded. CP 3: System Integration While we have analyzed several systems that have integrated the speculative execution for LLMs, more systems are coming out with diverse and advanced properties that have not been considered in the design of speculative execution yet. Therefore, taking into consideration the highlighted features in these new systems will be a never-ending track that should be noted by the research community. CP 4: Objective Optimization Currently, speculative execution in LLMs are mainly utilized to enhance the opendomain generation speed. Nonetheless, different settings would possibly require different attention mechanisms to the pick of objectives. For example, the combination of speculative decoding and contrastive decoding would benefit overcoming the hallucination problem with reduced generation latency. In view of this, flexible combinations to or proper ablations from speculative execution in LLMs should be raised if necessary for specific objectives. Finally, we would like to conclude that speculative execution is an important and promising area where a range of challenges are yet to be tackled."
+        }
+    ]
+}
\ No newline at end of file