Recent advances in natural language processing have enabled powerful privacy-invasive authorship attribution. To counter authorship attribution, researchers have proposed a variety of rule-based and learning-based text obfuscation approaches. However, existing authorship obfuscation approaches do not consider the adversarial threat model. Specifically, they are not evaluated against adversarially trained authorship attributors that are aware of potential obfuscation. To fill this gap, we investigate the problem of adversarial authorship attribution for deobfuscation. We show that adversarially trained authorship attributors are able to degrade the effectiveness of existing obfuscators from 20-30% to 5-10%. We also evaluate the effectiveness of adversarial training when the attributor makes incorrect assumptions about whether and which obfuscator was used. While there is a a clear degradation in attribution accuracy, it is noteworthy that this degradation is still at or above the attribution accuracy of the attributor that is not adversarially trained at all. Our results underline the need for stronger obfuscation approaches that are resistant to deobfuscation. Recent advances in natural language processing have enabled powerful attribution systems 1 that are capable of inferring author identity by analyzing text style alone (Abbasi and Chen, 2008; Narayanan et al., 2012; Overdorf and Greenstadt, 2016; Stolerman et al., 2013; Ruder et al., 2016). There have been several recent attempts to attribute the authorship of anonymously published text using  This paper is third in the series. See (Mahmood et al., 2019) and (Mahmood et al., 2020) for the first two papers. Our code and data are available at: https://github. such advanced authorship attribution approaches. 2 This poses a serious threat to privacy-conscious individuals, especially human rights activists and journalists who seek anonymity for safety. Researchers have started to explore text obfuscation as a countermeasure to evade privacy-invasive authorship attribution. Anonymouth (McDonald et al., 2012; Brennan et al., 2012) was proposed to identify words or phrases that are most revealing of author identity so that these could be manually changed by users seeking anonymity. Since it can be challenging for users to manually make such changes, follow up work proposed rule-based text obfuscators that can automatically manipulate certain text features (e.g., spelling or synonym) (Mc-Donald et al., 2013; Almishari et al., 2014; Keswani et al., 2016; Karadzhov et al., 2017; Castro-Castro et al., 2017; Mansoorizadeh et al., 2016; Kacmarcik and Gamon, 2006; Kingma and Welling, 2018). Since then more sophisticated learning-based text obfuscators have been proposed that automatically manipulate text to evade state-of-the-art authorship attribution approaches (Karadzhov et al., 2017; Shetty et al., 2018; Li et al., 2018; Mahmood et al., 2019; Grndahl and Asokan, 2020). In the arms race between authorship attribution and authorship obfuscation, it is important that both attribution and obfuscation consider the adversarial threat model (Potthast et al., 2018). While recent work has focused on developing authorship obfuscators that can evade state-of-the-art authorship attribution approaches, there is little work on developing authorship attribution approaches that can work against state-of-the-art authorship obfuscators. Existing authorship attributors are primarily designed for the non-adversarial threat model and only evaluated against non-obfuscated documents. Thus, it is not surprising that they can be readily evaded by state-of-the-art authorship obfuscators 2 https://www.nbcchicago.com/news/politics/Science-May-Help-Identify-Opinion-Columnist-492649561.html 7372 (Karadzhov et al., 2017; Shetty et al., 2018; Li et al., 2018; Mahmood et al., 2019; Grndahl and Asokan, 2020). To fill this gap, we investigate the problem of authorship deobfuscation where the goal is to develop adversarial authorship attribution approaches that are able to attribute obfuscated documents. We study the problem of adversarial authorship attribution in the following two settings. First, we develop attributors that filter obfuscated documents using obfuscation/obfuscator detectors and then use an authorship attributor that is adversarially trained on obfuscated documents. Second, we develop adversarially trained authorship attributors that does not make assumptions about whether and which authorship obfuscator is used. The results show that our authorship deobfuscation approaches are able to significantly reduce the adverse impact of obfuscation, which results in up to 20-30% degradation in attribution accuracy. We find that an authorship attributor that is purpose-built for obfuscated documents is able to improve attribution accuracy to within 5% as without obfuscation. We also find that an adversarially trained authorship attributor is able to improve attribution accuracy to within 10% as without obfuscation. Additionally, we evaluate the effectiveness of adversarial training when the attributor makes incorrect assumptions about whether and which obfuscator is used. We find that these erroneous assumptions degrade accuracy up to 20%, however, this degradation is the same or smaller than when the attributor is not adversarially trained, which can degrade accuracy up to 32%. Ethics Statement: We acknowledge that authorship deobfuscation in itself is detrimental to privacy. Our goal is to highlight a major limitation of prior work on authorship obfuscation under the adversarial threat model. We expect our work to foster further research into new authorship obfuscation approaches that are resistant to deobfuscation. Authorship attribution is the task of identifying the correct author of a document given a range of possible authors. It has been a long-standing topic, and researchers have developed a wide range of solutions to the problem. Earlier researchers focus more on analysis based on writing style features. These include the distribution of word counts and basic Bayesian methods (Mosteller and Wallace, 1963), different types of writing-style features (lexical, syntactic, structural, and content-specific) (Zheng et al., 2006), and authors' choices of synonyms (Clark and Hannon, 2007). Other researchers combined machine learning and deep learning methods with stylometric features. Abbasi and Chen (2008) combine their rich feature set, Writeprints, with an SVM. Brennan et al. (2012) improve Writeprints to reduce the computational load required of the feature set. Finally, more recent research focuses on fine-tuning pre-trained models since they do not require predefined features sets. Ruder et al. (2016) tackle authorship attribution with a CNN, while Howard and Ruder (2018) introduce the Universal Language Model Fine-tuning (ULMFiT) which shows strong performance in attribution. To the best of our knowledge, prior work lacks approaches for adversarial authorship deobfuscation. Prior work has shown that existing authorship attributors do not perform well against obfuscators. Brennan et al. (2012) present a manual obfuscation experiment which causes large accuracy degradation. Since this obfuscation experiment, much has been done in the area of authorship text obfuscation (Rao and Rohatgi, 2000; Brennan et al., 2012; McDonald et al., 2012, 2013; Karadzhov et al., 2017; Castro et al., 2017; Mahmood et al., 2019; Grndahl and Asokan, 2020; Bo et al., 2019). We focus on state-of-the-art obfuscators, MutantX (Mahmood et al., 2019) and DS-PAN (Castro et al., 2017) specifically in our research. Other obfuscation methods are as vulnerable to adversarial training which is reinforced in (Grndahl and Asokan, 2020). Our proposed authorship attributor leverages adversarial training to attribute documents regardless of obfuscation. First described in (Goodfellow et al., 2014), adversarial training uses text produced by an adversary to train a model to be more robust. Adversarial training has seen success in other text domains including strengthening word embeddings 7373 (Miyato et al., 2016), better classification in cross-lingual texts (Dong et al., 2020), and attacking classifiers (Behjati et al., 2019). We start by describing the threat model for the authorship deobfuscation attack. There is an arms race between an attacker (who desires to iden-tify/attribute the author of a given document) and a defender (an author who desires privacy and therefore uses an obfuscator to protect their identity). Figure 1 illustrates the expected workflow between the defender and the attacker. The defender uses an obfuscator before publishing the documents and the attacker employs obfuscation and/or obfuscator detector as well as an adversarially trained attributor for deobfuscation. Defender. The goal of the defender is to obfuscate a document so that it cannot be attributed to the author. The obfuscator takes as input an original document and obfuscates it to produce an obfuscated version that is expected to evade authorship attribution. Attacker. The goal of the attacker is to use an attributor trained on documents from multiple authors to identify the author of a given document. The attacker assumes to know the list of potential authors in the traditional closed-world setting. We examine two scenarios: First, as shown in Figure 1a, the attacker assumes to know that the document is obfuscated and also the obfuscator used by the defender. In this scenario, the attacker is able to access the documents that are produced by the obfuscator and hence train an attributor for obfuscated documents from the obfuscator. Second, as shown in Figure 1b, the attacker assumes to know that the document is obfuscated and that there is a pool of available obfuscators, of which one is used by the defender. Note that the attacker does not know exactly which obfuscator from the pool was used by the defender. Thus, the attacker trains an attributor for documents that are obfuscated by any one of the pool of available obfuscators. We use two state-of-the-art text obfuscators . Document Simplification (DS-PAN). This approach obfuscates documents through rule-based sentence simplification (Castro et al., 2017). The transformation rules include lexical transformations, substitutions of contractions or expansions, and eliminations of discourse markers and fragments of text in parenthesis. This approach was one of the best performing in the annual PAN competition, a shared CLEF task (Potthast et al., 2017). It was also one of the few approaches that achieves "passable" and even "correct" judgements on the soundness of obfuscated text (i.e., whether the semantics of the original text are preserved) (Hagen et al., 2017). We refer to this approach as DS-PAN. Mutant-X. This approach performs obfuscation using a genetic algorithm based search framework (Mahmood et al., 2019). It makes changes to input text based on the attribution probability and semantics iteratively so that obfuscation improves at each step. It is also a fully automated authorship obfuscation approach and outperformed text obfuscation approaches from PAN (Potthast et al., 2017) and has since been used by other text obfuscation approaches (Grndahl and Asokan, 2020). There are two versions of Mutant-X: Mutant-X writeprintsRFC, which uses Random Forests along with Writeprints-Static features (Brennan et al., 2012); and Mutant-X embeddingCNN, which uses a Convolutional Neural Network (CNN) classifier with word embeddings. We use writeprintsRFC version because it achieves better drop in attribution accuracy and semantic preservation as compared to embeddingCNN. We describe the design of the authorship attributor and our adversarial training approaches for deobfuscation. Authorship Attributor. We use writeprintsRFC as the classifier for authorship attribution. More specifically, we use the Writeprints-Static feature set (Brennan et al., 2012) that includes lexical features on different levels, such as word level (total number of words) and letter level (letter frequency) as well as syntactic features such as the frequency of functional words and parts of speech tags. It is one of the most widely used stylometric feature sets and has consistently achieved high accuracy on different datasets and author sets while maintaining a low computational cost. We then use these features to train an ensemble random forest classifier 7374 Input Documents Author: 7 Author: 8 Author: 0 ... Adversarial Training. The basic idea of adversarial training is to include perturbed/obfuscated inputs into the training set to improve the model's resistance towards such adversarially obfuscated inputs (Goodfellow et al., 2014). It has been widely used in various domains including text classification. In our case, obfuscated texts are texts that vary slightly from the original texts and these serve as adversarial examples. We examine how using these adversarial examples as training data influ-ences the attributor's performance and whether it adds resilience against obfuscation. Based on our two scenarios described in Section 3.1 and shown in Figure 1, we propose two ways of adversarial training. For both cases, original texts from the list of possible authors are selected and prepared for obfuscation. For scenario 1, we train the attributor using documents obfuscated by a known obfuscator. For scenario 2, since the attacker does not assume to know the specific obfuscator used by the defender, we train the attributor using documents obfuscated by the pool of available obfuscators. We describe the dataset, evaluation metrics, and experimental design to assess the effectiveness of our adversarial authorship attribution approaches for deobfuscation. Dataset. Following previous research (Mahmood et al., 2019), we examine a publicly available dataset for evaluation of our methodology. The Blog Authorship Corpus (Schler et al., 2006) contains over 600,000 blog posts from blogger.com. These posts span 19,320 unique authors. Previous research (Narayanan et al., 2012) found that authorship attribution gets harder when more authors are included. Based on the author selection in (Mahmood et al., 2019), we select a subset of 15 each with 100 documents (compared to their 5 and 10 authors) for a more precised evaluation. These Input Documents Obfuscators Attributor writeprintsRFC Attribution Results Author: 7 Author: 8 Author: 0 ... 1500 documents are divided into 80-20% split for training and testing, respectively. Specifically, 80 documents from each author are used in the training set while the rest 20 documents are used in the test set. As shown in Figure 2, we train on various combinations of obfuscated documents. These documents are obfuscated by the obfuscators described in Section 3.2. When an attributor-dependent-obfuscator (e.g. Mutant-X (Mahmood et al., 2019)) is used, the attributor will have access to the same training documents used to train the obfuscator. Otherwise, the attributor does not assume to have access to the attributor used by the obfuscator. To control for training size, when more than 1 obfuscator is used, we sample equal amounts of documents from each set of obfuscated documents. For example, if we train against 2 obfuscators, then 600 documents are sampled from each set of respective obfuscated documents to get a training set of size 1200. To calibrate the obfuscated texts, we use METEOR score (Banerjee and Lavie, 2005) to evaluate the soundness of documents. The score for Mutant-X ranges from 0.3 to 0.7 (mean=0.46), and the score for DS-PAN ranges from 0.24 to 0.57 (mean=0.38), which are comparable to previous studies (Mahmood et al., 2019). An in-depth analysis of the METEOR score is reported in Appendix A. Metric. 15-class problem, we calculate the accuracy as: Attack Scenarios. Figure 3 illustrates the flow of our experimental evaluation under different attack scenarios. 0. Baseline: For the baseline model, we assume that there is no obfuscation in this world. The attacker is trained on original documents and is deployed on original documents. 1. Obfuscation-unaware-attacker: The first case we examine is when the defender actively seeks to hide author identity. Thus, the defender gains an advantage by obfuscating documents using either Mutant-X or DS-PAN in order to bypass the attacker. The attacker, however, remains unaware of obfuscation and trains the attributor only on original documents. 2. Obfuscation-aware-attacker with obfuscation detector: Next, we give knowledge of obfuscation to the attacker by introducing an obfuscation detector into the system. Previous research (Mahmood et al., 2020) shows that texts generated by existing obfuscators can be detected as obfuscated with high accuracy. The device for this type of detection is called an obfuscation detector. Hence, in this scenario we ask whether there is any benefit to the attacker if the text is identified as obfuscated before attribution. Since the attacker does not know which obfuscator was used by the defender, the attributor is trained on the combination of documents generated from DS-PAN and from Mutant-X. The defender is the same as in the previous scenario, i.e., it uses one of the obfuscators to generate documents. 3. Obfuscator-aware-attacker with obfuscator detector: We give additional information to the attacker. Previous research has shown that embedding watermarks and fingerprints that show the identity of the model into deep neural networks is a valid approach to protect the rights of shared trained models (Uchida et al., 2017; Zhang et al., 2018). Hence, it is reasonable to assume that there will be methods in the future to identify the watermarks for specific deep neural networks. Here, we propose the concept of obfuscator detector, which can detect the specific obfuscator used. In this case, the attacker attributor is trained always on the documents generated by the same obfuscator as the defender: either documents generated from DS-PAN or from Mutant-X. 2i. Obfuscation-aware-attacker with incorrect obfuscation detector: Here we ask the question: what happens in scenario 2 if the obfuscation detector makes errors? The specific error addressed is that the detector classifies the text as obfuscated whereas it is actually an original. Under this condition, the attacker attributor is still trained on the combination of documents generated from DS-PAN and from Mutant-X. But the defender now presents an original document. 3i. Obfuscator-aware-attacker with incorrect obfuscator detector: When the obfuscator detector classifies incorrectly, it assumes that the defender uses a specific obfuscator when it actually uses a different one. The attacker attributor is trained on the documents generated by one of the obfuscators: either documents generated from DS-PAN or from Mutant-X. However, the defender uses a different obfuscator than the attacker to generate the documents. 4. Obfuscator-aware-attacker that does not rely on an obfuscator detector or obfuscation detector: Since the previous processes require the proposed obfuscation and obfuscator detector, it is not efficient. Hence, a simpler, more efficient solution is to train on all the documents at once. In this sim-plified version, the attacker attributor is trained on the combination of original documents, documents generated from DS-PAN, and documents generated from Mutant-X. Since this is the combined condition, the defender may or may not use an obfuscator, and will choose from the two possible obfuscators to generate documents. In this section, we present the results following the progression of various attack scenarios shown in Figure 3. 5.1 Major Scenarios 0. Baseline: The original authorship attributor has an accuracy of 76.7% when trained on the original documents and tested on original documents. The attribution accuracy should be higher than 6.7%, which is when we attribute the 15 authors randomly, to be considered effective. 1. Obfuscation-unaware-attacker: Based on the first row of Table 1, the result shows that the attribution accuracy drops from 76.7% to 50.7% with a decrease of 26% when tested on DS-PAN obfuscated documents, while the accuracy for testing on Mutant-X obfuscated documents drops from 76.7% to 44.3%. The average drop in accuracy is from 76.7% to 47.5%, which is 29.2%. Based on the results, we know that as shown by previous works (Karadzhov et al., 2017; Mahmood et al., 2019) on the performance of the obfuscators, DS-PAN and Mutant-X obfuscators can successfully decrease the attribution accuracy of original attributor. 2. Obfuscation-aware-attacker with obfuscation detector: The second row of Table 1 shows that attribution accuracy increases by 13.2% from 50.7% to 63.9% when tested on DS-PAN documents, and increases by 24.7% from 44.3% to 69% when tested on Mutant-X documents. The average accuracy is 66.4%, which increases from the previous 47.5% by about 19%. While the performance is still not comparable to the baseline results, the increase in accuracy from the previous scenario is significant, which suggests that the obfuscation detector would benefit the performance against obfuscated documents. 3. Obfuscator-aware-attacker with obfuscator detector: As shown on the third and forth row of Table 1, when trained only on DS-PAN documents, the accuracy tested on DS-PAN is 68.6%, with an increase of 17.9% from the first scenario; when trained only on Mutant-X documents, the accuracy tested on Mutant-X is 75.7%, with an increase of 31.4%. The average test accuracy is 71.1%, which increases by about 5% compared to the 66.4% in the previous case. From the results, we can see that having an obfuscator detector as well as an obfuscation detector is the most beneficial to improve the attribution accuracy from obfuscated texts. Although obfuscation/obfuscator detector are quite accurate, they are not perfect. Hence, we test the success of the attacker when the obfuscation detector and obfuscator detector are incorrect. 2i. Obfuscation-aware-attacker with incorrect obfuscation detector: Shown on the first column of row four on Table 2, the attribution accuracy decreases by 8.4% from the baseline 76.7% to 68.3%, but a higher accuracy is maintained than the average of Attack Scenario 2 (66.4%) The result shows that when the obfuscation detector produces wrong results, performance will be influenced, but still stay at a relatively high level. Thus, having an obfuscation detector is generally good for the attacker with little cost. 3i. Obfuscator-aware-attacker with incorrect obfuscator detector: From second and third rows of Table 2 we see that when the attacker is trained only on DS-PAN documents, the accuracy tested on Mutant-X is 57.3%, with a drop in performance of 18.4% when compared to training on only MutantX documents (75.7%). When the attacker is trained only on Mutant-X documents, the accuracy tested on DS-PAN is 48.5%, with a drop in performance of 20.1% as compared to training on only DS-PAN documents (68.6%). The average test accuracy is 52.9%, which is lower than training on the same obfuscator, but higher than the results in 1 of 5.1 (50.7% and 44.3%). When the obfuscator detector gives incorrect results, the attribution accuracy will not achieve its best performance, but the result is still higher than trained only on original documents. Hence, using obfuscated documents to train always tends to benefit the attribution accuracy. Here the attacker simply uses originals and obfuscated documents from all available obfuscators for adversarial training of the attributor. 4. Obfuscator-aware-attacker that does not rely on an obfuscator detector or obfuscation detector: 7377 This result is shown on the last row of Table 2. Attribution accuracy when tested on original documents drops from 76.7% to 66.3%, but increases by 10.5% from 50.7% to 61.2% when tested on DS-PAN, and increases by 24.5% from 44.3% to 68.8% when tested on Mutant-X. The average accuracy is 65%, which increases from the average of the former three, 57.2%, by about 8%. While the attacker does not know if the document is obfuscated or not, or by which obfuscator, it is still able to achieve a high boost in attribution accuracy by adversarial training. Therefore, although the previous processes can achieve higher performances, training on a combination of these documents could be a valid approach when time and resources are limited. Next, we look more closely into the results from adversarial training to better understand them. Figure 4 pesents the confusion matrices produced from DS-PAN obfuscated documents tested on Attack Scenario 1, 2 and 3 respectively. Rows represent the Original Authors, while the columns represent the Predicted Authors. The values in the matrices are the percentage of the original documents that are classified as a specific author. Moving from scenario 1 to 3, we see an increase in color density and percentage on the diagonal, which signifies the general increase in accuracy when the training documents become more specific. Consistent with above, the color on the nondiagonal areas becoming more transparent also indicates reduction of classification errors. At the author level, we observe that almost all of the authors show increases in accuracy on the diagonal cells across the three scenarios. It shows that adversarial training is effective even on authors with different styles. Looking more closely at each author, we know that Author 9 is the easiest to classify performance is always at 100%. Author 6, on the other hand, is relatively hard to attribute. The best performance for Author 6 is only 35% from the most effective Attack Scenario 3. Figure 6 presents another view on performance. It shows the percentage of errors made for each author out of all the errors in the three scenarios combined (note: the sum of all errors in the figure is 100%). Thus, the errors made for Author 1 under Scenario 1 is 3.18% of total errors across the three scenarios. We observe that the color is generally darker in Scenario 1, while it gradually lightens in Scenario 2 and then in Scenario 3. Again, this indicates the benefit of having more specific training data. Looking more closely within each scenario, we see that the attributor of Attacker Scenario 1 tends to misclassify Authors 5 and 8 the most. But the attributors for Scenario 2 and Scenario 3 learn more effectively for these two authors thereby reducing mistakes. For Attack Scenario 3, the most misclassified author is Author 6, where 3.76% of all errors. But this percentage is still an improvement over the 4.34% in the previous two scenarios. Motivated by the above observations, next we investigate shifts in performance for a specific author. We assign labels to the 15 authors in the dataset and select Original Author 15 for more detailed analysis. The reason we choose Author 15 is that its accuracy is among the ones that increases the most, from 45% to 80%. In order to find out the reasons behind such increase, we perform PCA analysis on all of the DS-PAN documents whose original author is Author 15. We use Writeprints-Static feature set, which has a total of 555 features. In order to preserve the most significant features for attribution, we select the most important 25 features from the original writeprintsRFC and process them through PCA so that we can visualize the features into 3 dimensional graphs. As shown in the graphs in Figure 5, each dot on the graph represents a document. The green ones are the ones that are attributed correctly while the red ones are attributed incorrectly. In Figure 5a, the incorrectly attributed ones are mainly gathered in a cluster. This suggests that the attributor has trouble discriminating the documents that are similar to each other. But as we go from left to right, the documents in the cluster are also gradually attributed correctly. The trend shows that the attributor is getting better at distinguishing between documents that are similar to each other. Hence, we can infer that adversarial training improves attribution accuracy by discriminating between the ones that are more similar to each other. In Attack Scenarios 2, 3, and 4, the test sets using DS-PAN for obfuscation yield worse attribution Page 5 of 13 (a) Attack Scenario 1 9/11/21, 7 : 36 PM ConfusionMatrix.ipynb Colaboratory Page 6 of 13 https://colab.research.google.com/drive/1YApk0ceP2Q0KPpJZ03JWAzVc-oR5UiZo Text(0.5, 57.5, 'Predicted Author') plt.figure(figsize=(10,10))sns.set(font_scale=1.7)sns.heatmap(cm2, annot=annot2, fmt='', cmap = "Blues", cbar = None, yticklabels=list( plt.ylabel('Original Author',**axis_font) plt.xlabel('Predicted Author',**axis_font) plt.figure(figsize=(10,10)) (b) Attack Scenario 2 9/11/21, 7 : 36 PM ConfusionMatrix.ipynb Colaboratory Page 7 of 13 https://colab.research.google.com/drive/1YApk0ceP2Q0KPpJZ03JWAzVc-oR5UiZo Text(0.5, 57.5, 'Predicted Author') plt.figure(figsize=(10,10))sns.set(font_scale=1.7)sns.heatmap(cm3, annot=annot3, fmt='', cmap = "Blues", cbar = None, yticklabels=list( plt.ylabel('Original Author',**axis_font) plt.xlabel('Predicted Author',**axis_font) plt.figure(figsize=(10,10)) (c) Attack Scenario 3 Figure 4: Confusion matrices of different attack scenarios 9/11/21, 7 : 18 PM PCA4&5&8.ipynb Colaboratory Page 5 of 57 https://colab.research.google.com/drive/1Ly5vXBk_ZQ3ZUj4y1eIUOghjvwLxdQL0 [ 2 9 11 14 9 9 9 6 14 9 3 14 14 14 14 14 13 9 14 14] x = df1.drop(labels=['Filename','Original','Predicted_Orig','Obfuscator','Predicted_DS' color = (a) Attack Scenario 1 9/11/21, 7 : 18 PM PCA4&5&8.ipynb Colaboratory Page 6 of 57 https://colab.research.google.com/drive/1Ly5vXBk_ZQ3ZUj4y1eIUOghjvwLxdQL0 8 : 'g', 1 : 'lightcoral', 10: 'purple', 0: 'yellowgreen', } label_color = [LABEL_COLOR_MAP[l] for l in color] label_color = np.asarray(label_color) ax.scatter(x_trans[y==14, 0], x_trans[y==14, 1], x_trans[y==14, 2], c='yellowgreen' label='Correct') ax.scatter(x_trans[y!=14, 0], x_trans[y!=14, 1], x_trans[y!=14, 2], c='lightcoral', s = label='Incorrect') # Hide grid lines ax.grid(False) # Hide axes ticks ax.set_xticks([]) ax.set_yticks([]) ax.set_zticks([]) ax.w_xaxis.gridlines.set_lw(3.0) ax.w_yaxis.gridlines.set_lw(3.0) ax.w_zaxis.gridlines.set_lw(3.0) #ax.legend() #plt.title('PCA of DS') plt.show() x = df1.drop(labels=['Filename','Original','Predicted_Orig','Obfuscator','Predicted_DS' x = df1.drop(labels=['Filename','Original','Predicted_Orig','Obfuscator','Predicted_DS','Predicted_MX','Predicted_Mix','Combined'], (b) Attack Scenario 2 9/11/21, 7 : 18 PM PCA4&5&8.ipynb Colaboratory Page 8 of 57 https://colab.research.google.com/drive/1Ly5vXBk_ZQ3ZUj4y1eIUOghjvwLxdQL0 # Hide axes ticks ax.set_xticks([]) ax.set_yticks([]) ax.set_zticks([]) ax.legend() #plt.title('PCA of DS') plt.show() 2D plot ## Print Original Graph x = df1.drop(labels=['Filename','Original','Predicted_Orig','Obfuscator','Predicted_DS' y = https://colab.research.google.com/drive/1YApk0ceP2Q0KPpJZ03JWAzVc-oR5UiZo (annot).round(2) annot = annot.astype('str') sns.set(font_scale=1.7)sns.heatmap(dfx*100, fmt='', annot = annot, cmap = "Reds", yticklabels=list(range(1 plt.ylabel('Author',**axis_font)plt.xlabel('Attack Scenario',**axis_font) Figure 6: Percentage of misclassified document for each author across attack scenarios accuracy than those using Mutant-X. Our analysis of obfuscated documents showed that DS-PAN makes both a greater number of changes as well as more significant changes as compared to Mutant-X. Thus, we surmise that DS-PAN results in larger degradation in attribution accuracy because the at-tacker's training set contains text that is less similar to the original text. However, the changes made by DS-PAN also have side effect in that they lower the soundness of obfuscated text as reflected by lower METEOR scores. The mean METEOR score for DS-PAN is 0.38 as compared to 0.46 for Mutant-X. A more detailed analysis of METEOR score and semantic similarity between obfuscated and original texts is reported in Appendix A. 6.4 Insights into Adversarial Training The performance gain of adversarial training comes from a "noisy" training dataset comprising of obfuscated documents as well as knowledge about the obfuscator. To disentangle these two factors, we compare the accuracy improvements of the second and third rows of Table 2 against the Mutant-X obfuscated test documents. We note that the improvement in attribution accuracy is 13% when DS-PAN obfuscated documents are used for training. The improvement in attribution accuracy is further 18% (31% overall) when Mutant-X obfuscated documents are used for training. This difference (13% vs. 18%) indicates that although having a noisy dataset helps, the knowledge of the specific obfuscator is likely more crucial to improving attribution performance. In this work, we explored the novel problem of adversarial authorship attribution for deobfuscation. We demonstrate that adversarial training is able to significantly reduce the adverse impact of existing text obfuscators on authorship attribution accuracy. We found that an adversarially trained authorship attributor improves attribution accuracy to within 5-10% as without obfuscation. While an adversarially trained authorship attributor achieved best accuracy when it is trained using the documents obfuscated by the respective obfuscator, we found that it achieves reasonable accuracy even when it is trained using documents obfuscated by a pool of obfuscators. When the adversarially trained attributor makes erroneous assumptions about the obfuscator used to obfuscate documents, we note a degradation in attribution accuracy. It is noteworthy, however, that this degradation is still similar or better than the attribution accuracy of the baseline attributor that is not adversarially trained. Our results shed light into the future of the ensuing arms race between obfuscators and attributors. Most notably, we find that the effectiveness of adversarial training is somewhat limited if the obfuscators continue to employ new and improved methods that are not available to attributors for adversarial training. Therefore, it is important to continue development of new and improved text obfuscation approaches that are resistant to deobfuscation (Bevendorff et al., 2019; Bo et al., 2019; Grndahl and Asokan, 2020; Hlavcheva et al., 2021). On the other hand, recent work on understanding and improving transferability of adversarial attacks can inform development of better adversarial attributors that might work well even for unknown obfuscators (Tramr et al., 2017; Zheng et al., 2020; He et al., 2021; Mireshghallah and Berg-Kirkpatrick, 2021). Finally, our experiments were limited to the closed-world setting where the universe of potential authors is assumed to be known by the attributor. Further research is needed to investigate whether (and how much) adversarial algorithms are effective in the open-world setting.
abstain abstain abstain abstain objective result method abstain result abstain method abstain other abstain abstain abstain abstain other abstain abstain abstain abstain other objective method objective objective result objective result method result abstain abstain abstain other other other other other other other other other abstain other other other method other objective other other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method method abstain method abstain abstain abstain abstain method abstain abstain method method method abstain method abstain abstain abstain method abstain abstain abstain method abstain abstain abstain method method method abstain abstain method abstain method method abstain method abstain abstain method abstain abstain method abstain abstain method abstain abstain method abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain abstain result abstain abstain abstain other abstain result abstain abstain abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain result abstain result abstain abstain abstain abstain abstain abstain abstain result abstain result abstain abstain abstain abstain abstain method result method result abstain abstain abstain abstain abstain abstain result abstain abstain other other other other other other abstain result result abstain abstain abstain method method abstain abstain objective objective result result method abstain result objective abstain abstain method abstain