txt/2202.13056.txt

1
Automated Identification of Toxic Code Reviews Using ToxiCR
JAYDEB SARKER, ASIF KAMAL TURZO, MING DONG, AMIANGSHU BOSU, Wayne State
University, USA
Toxic conversations during software development interactions may have serious repercussions on a Free and Open
Source Software (FOSS) development project. For example, victims of toxic conversations may become afraid
to express themselves, therefore get demotivated, and may eventually leave the project. Automated filtering of
toxic conversations may help a FOSS community to maintain healthy interactions among its members. However,
off-the-shelf toxicity detectors perform poorly on Software Engineering (SE) dataset, such as one curated from
code review comments. To encounter this challenge, we present ToxiCR, a supervised learning-based toxicity
identification tool for code review interactions. ToxiCR includes a choice to select one of the ten supervised learning
algorithms, an option to select text vectorization techniques, eight preprocessing steps, and a large scale labeled
dataset of 19,651 code review comments. Two out of those eight preprocessing steps are SE domain specific. With
our rigorous evaluation of the models with various combinations of preprocessing steps and vectorization techniques,
we have identified the best combination for our dataset that boosts 95.8% accuracy and 88.9% 𝐹11score. ToxiCR
significantly outperforms existing toxicity detectors on our dataset. We have released our dataset, pretrained
models, evaluation results, and source code publicly available at: https://github.com/WSU-SEAL/ToxiCR).
CCS Concepts: •Software and its engineering →Collaboration in software development ;Integrated and visual
development environments ;•Computing methodologies →Supervised learning .
Additional Key Words and Phrases: toxicity, code review, sentiment analysis, natural language processing, tool
development
ACM Reference Format:
Jaydeb Sarker, Asif Kamal Turzo, Ming Dong, Amiangshu Bosu. 2023. Automated Identification of Toxic
Code Reviews Using ToxiCR. ACM Trans. Softw. Eng. Methodol. 32, 1, Article 1 (January 2023), 33 pages.
https://doi.org/10.1145/3583562
1 INTRODUCTION
Communications among the members of many Free and Open Source Software(FOSS) communities
include manifestations of toxic behaviours [ 12,32,46,62,66,81]. These toxic communications may have
decreased the productivity of those communities by wasting valuable work hours [ 16,73]. FOSS developers
being frustrated over peers with ‘prickly’ personalities [ 17,34] may contemplate leaving a community for
good [11,26]. Moreover, as most FOSS communities rely on contributions from volunteers, attracting and
retaining prospective joiners is crucial for the growth and survival of FOSS projects [ 72]. However, toxic
interactions with existing members may pose barriers against successful onboarding of newcomers [ 48,83].
Therefore, it is crucial for FOSS communities to proactively identify and regulate toxic communications.
Author’s address: Jaydeb Sarker, Asif Kamal Turzo, Ming Dong, Amiangshu Bosu, jaydebsarker,asifkamal,mdong,amiangshu.
bosu, Wayne State University, Detroit, Michigan, USA.
Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee
provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and
the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be
honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists,
requires prior specific permission and/or a fee. Request permissions from permissions@acm.org.
©2023 Copyright held by the owner/author(s). Publication rights licensed to ACM.
1049-331X/2023/1-ART1 $15.00
https://doi.org/10.1145/3583562
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.arXiv:2202.13056v3  [cs.SE]  8 Feb 20231:2•Sarker, et al.
Large-scale FOSS communities, such as Mozilla, OpenStack, Debian, and GNU manage hundreds of
projects and generate large volumes of text-based communications among their contributors. Therefore,
it is highly time-consuming and infeasible for the project administrators to identify and timely intervene
with ongoing toxic communications. Although, many FOSS communities have codes of conduct, those are
rarely enforced due to time constraints [ 11]. As a result, toxic interactions can be easily found within
the communication archives of many well-known FOSS projects. As an anonymous FOSS developer
wrote after leaving a toxic community, “ ..it’s time to do a deep dive into the mailing list archives or
chat logs. ... Searching for terms that degrade women (chick, babe, girl, bitch, cunt), homophobic slurs
used as negative feedback (“that’s so gay”), and ableist terms (dumb, retarded, lame), may allow you to
get a sense of how aware (or not aware) the community is about the impact of their language choice on
minorities. ” [11]. Therefore, it is crucial to develop an automated tool to identify toxic communication of
FOSS communities.
Toxic text classification is a Natural Language Processing (NLP) task to automatically classify a text
as ‘toxic’ or ‘non-toxic’. There are several state-of-the-art tools to identify toxic contents in blogs and
tweets [7,9,39,54]. However, off-the-shelf toxicity detectors do not work well on Software Engineering
(SE) communications [ 77], since several characteristics of such communications (e.g., code reviews and
bug interactions) are different from those of blogs and tweets. For example, compared to code review
comments, tweets are shorter and are limited to a maximum length. Tweets rarely include SE domain
specific technical jargon, URLs, or code snippets [ 6,77]. Moreover, due to different meanings of some
words (e.g, ‘kill’, ‘dead’, and ‘dumb’) in the SE context, SE communications with such words are often
incorrectly classified as ‘toxic’ by off-the-shelf toxicity detectors [73, 77].
To encounter this challenge, Raman etal. developed a toxicity detector tool (referred as the ‘STRUDEL
tool’ hereinafter) for the SE domain [ 73]. However, as the STRUDEL tool was trained and evaluated
with only 611 SE texts. Recent studies have found that it performed poorly on new samples [ 59,70]. To
further investigate these concerns, Sarker et al. conducted a benchmark study of the STRUDEL tool and
four other off-the-shelf toxicity detectors using two large scale SE datasets [ 77]. To develop their datasets,
they empirically developed a rubric to determine which SE texts should be placed in the ‘toxic’ group
during their manual labeling. Using that rubric, they manually labeled a dataset of 6,533 code review
comments and 4,140 Gitter messages [ 77]. The results of their analyses suggest that none of the existing
tools are reliable in identifying toxic texts from SE communications, since all the five tools’ performances
significantly degraded on their SE datasets. However, they also found noticeable performance boosts (i.e.,
accuracy improved from 83% to 92% and F-score improved from 40% to 87%) after retraining two of the
existing off-the-shelf models (i.e., DPCNN [ 94] and BERT with FastAI [ 54]) using their datasets. Being
motivated by these results, we hypothesize that a SE domain specific toxicity detector can boost even
better performances, since off-the-shelf toxicity detectors do not use SE domain specific preprocessing
steps, such as preprocessing of code snippets included within texts. On this hypothesis, this paper presents
ToxiCR, a SE domain specific toxicity detector. ToxiCR is trained and evaluated using a manually labeled
dataset of 19,651 code review comments selected from four popular FOSS communities (i.e., Android,
Chromium OS, OpenStack and LibreOffice). We selected code review comments, since a code review
usually represents a direct interaction between two persons (i.e., the author and a reviewer). Therefore, a
toxic code review comment has the potential to be taken as a personal attack and may hinder future
collaboration between the participants. ToxiCR is written in Python using the Scikit-learn [ 67] and
TensorFlow [ 3]. It provides an option to train models using one of the ten supervised machine learning
algorithms including five classical and ensemble-based, four deep neural network-based, and a Bidirectional
Encoder Representations from Transformer (BERT) based ones. It also includes eight preprocessing
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.Automated Identification of Toxic Code Reviews Using ToxiCR •1:3
steps with two being SE domain specific and an option to choose from five different text vectorization
techniques.
We empirically evaluated various optional preprocessing combinations for each of the ten algorithms
to identify the best performing combination. During our 10-fold cross-validations evaluations, the best
performing model of ToxiCR significantly outperforms existing toxicity detectors on the code review
dataset with an accuracy of 95.8% and F-score of 88.9%.
The primary contributions of this paper are:
∙ToxiCR: An SE domain specific toxicity detector. ToxiCR is publicly available on Github at:
https://github.com/WSU-SEAL/ToxiCR.
∙An empirical evaluation of ten machine learning algorithms to identify toxic SE communications.
∙Implementations of eight preprocessing steps including two SE domain specific ones that can be
added to model training pipelines.
∙An empirical evaluation of three optional preprocessing steps in improving the performances of
toxicity classification models.
∙Empirical identification of the best possible combinations for all the ten algorithms.
Paper organization: The remainder of this paper is organized as following. Section 2 provides a brief
background and discusses prior related works. Section 3 discusses the concepts utilized in designing
ToxiCR. Section 4 details the design of ToxiCR. Section 5 details the results of our empirical evaluation.
Section 6 discusses the lessons learned based on this study. Section 7 discusses threats to validity of our
findings. Finally, Section 8 provides a future direction based on this work and concludes this paper.
2 BACKGROUND
This section defines toxic communications, provides a brief overview of prior works on toxicity in FOSS
communities and describes state-of-the-art toxicity detectors.
2.1 What constitutes a toxic communication?
Toxicity is a complex phenomenon to construct as it is highly subjective than other text classification
problems (i.g., online abuse, spam) [ 53]. Whether a communication should be considered as ‘toxic’ also
depends on a multitude of factors, such as communication medium, location, culture, and relationship
between the participants. In this research, we focus specially on written online communications. According
to the Google Jigsaw AI team, a text from an online communication can be marked as toxic if it contains
disrespectful or rude comments that make a participant to leave the discussion forum [ 7]. On the other
hand, the Pew Research Center marks a text as toxic if it contains threat, offensive call, or sexually
expletive words [ 28]. Anderson etal.’s definition of toxic communication also includes insulting language
or mockery [ 10]. Adinolf and Turkay studied toxic communication in online communities and their views
of toxic communications include harassment, bullying, griefing (i.e, constantly making other players
annoyed), and trolling [ 5]. To understand, how persons from various demographics perceive toxicity,
Kumaretal. conducted a survey with 17,280 participants inside the USA. To their surprise, their results
indicate that the notion toxicity cannot be attributed to any single demographic factor [ 53]. According to
Miller et al., various antisocial behaviors fit inside the Toxicity umbrella such as hate speech, trolling,
flaming, and cyberbullying [ 59]. While some of the SE studies have investigated antisocial behaviors
among SE communities using the ‘toxicity’ construct [ 59,73,77], other studies have used various other
lens such as incivility [ 33], pushback [ 29], and destructive criticism [ 40]. Table 1 provides a brief overview
of the studied constructs and their definitions.
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.1:4•Sarker, et al.
SE study Construct Definition
Sarker et
al. [77]Toxicity “includes any of the following: i) offensive name calling, ii) insults,
iii) threats, iv) personal attacks, v) flirtations, vi) reference to
sexual activities, and vii) swearing or cursing. ”
Miller et
al. [59]Toxicity “an umbrella term for various antisocial behaviors including
trolling, flaming, hate speech, harassment, arrogance, entitlement,
and cyberbullying ”.
Ferreira et
al. [33]Incivility “features of discussion that convey an unnecessarily disrespectful
tone toward the discussion forum, its participants, or its topics ”
Gunawardena
et al. [40]Destructive
criticismnegative feedback which is nonspecific and is delivered in a harsh or
sarcastic tone, includes threats, or attributes poor task performance
to flaws of the individual.
Egelman et
al. [29]Pushback “the perception of unnecessary interpersonal conflict in code review
while a reviewer is blocking a change request ”
Table 1. Anti-social constructs investigated in prior SE studies
2.2 Toxic communications in FOSS communities
Several prior studies have identified toxic communications in FOSS communities [ 21,66,73,77,81]. Squire
and Gazda found occurrences of expletives and insults in publicly available IRC and mailing-list archives of
top FOSS communities, such as Apache, Debian, Django, Fedora, KDE, and Joomla [ 81]. More alarmingly,
they identified sexist ‘maternal insults’ being used by many developers. Recent studies have also reported
toxic communications among issue discussions on Github [73], and during code reviews [33, 40, 66, 77].
Although toxic communications are rare in FOSS communities [ 77], toxic interactions can have severe
consequences [ 21]. Carillo etal. termed Toxic communications as a ‘poison’ that impacts mental health
of FOSS developers [ 21], and may contribute to stress and burnouts [ 21,73]. When the level of toxicity
increases in a FOSS community, the community may disintegrate as developers may no longer wish
to be associated with that community [ 21]. Moreover, toxic communications hamper onboarding of
prospective joiners, as a newcomer may get turned off by the signs of a toxic culture prevalent in a
FOSS community [ 48,83]. Milleretal. conducted a qualitative study to better understand toxicity in
the context of FOSS development [ 59]. They created a sample of 100 Github issues representing various
types of toxic interactions such as insults, arrogance, trolling, entitlement, and unprofessional behaviour.
Their analyses also suggest that toxicity in FOSS communities differ from those observed on other online
platforms such as Reddit or Wikipedia [59].
Ferreira et al. [ 33] investigated incivility during code review discussions based on a qualitative analysis
of 1,545 emails from Linux Kernel Mailing Lists and found that the most common forms of incivility
among those forums are frustration, name-calling, and importance. Egelman et al. studied the negative
experiences during code review, which they referred as “pushback”, a scenario when a reviewer is blocking a
change request due to unnecessary conflict [ 29]. Qiu et al. further investigated such “pushback” phenomena
to automatically identify interpersonal conflicts [ 70]. Gunawardena et al. investigated negative code review
feedbacks based on a survey of 93 software developers, and they found that destructive criticism can be a
threat to gender diversity in the software industry as women are less motivated to continue when they
receive negative comments or destructive criticisms [40].
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.Automated Identification of Toxic Code Reviews Using ToxiCR •1:5
2.3 State of the art toxicity detectors
To combat abusive online contents, Google’s Jigsaw AI team developed the Perspective API (PPA),
which is publicly available [ 7]. PPA is one of the general purpose state-of-the-art toxicity detectors. For a
given text, PPA generates the probability (0 to 1) of that text being toxic. As researchers are working to
identify adversarial examples to deceive the PPA [ 44], the Jigsaw team periodically updates it to eliminate
identified limitations. The Jigsaw team also published a guideline [ 8] to manually identify toxic contents
and used that guideline to curate a crowd-sourced labeled dataset of toxic online contents [ 2]. This
dataset has been used to train several deep neural network based toxicity detectors [ 22,30,37,39,82,86].
Recently, Bhat et al.proposed ToxiScope , a supervised learning-based classifier to identify toxic on
workplace communications [ 14]. However, ToxiScope’s best model achieved a low F1-Score (i.e., =0.77)
during their evaluation
One of the major challenges in developing toxicity detectors is character-level obfuscations, where one
or more characters of a toxic word are intentionally misplaced (e.g. fcuk), or repeated (e.g., shiiit), or
replaced (e.g., s*ck) to avoid detection. To address this challenge, researchers have used character-level
encoders instead of word-level encoders to train neural networks [ 54,60,63]. Although, character-level
encoding based models can handle such character level obfuscations, they come with significant increments
of computation times [ 54]. Several studies have also found racial and gender bias among contemporary
toxicity detectors, as some trigger words (i.e., ‘gay’, ‘black’) are more likely to be associated with false
positives (i.e, a nontoxic text marked as toxic) [75, 85, 89].
However, off-the-shelf toxicity detectors suffer significant performance degradation on SE datasets [ 77].
Such degradation is not surprising, since prior studies found off-the-shelf natural language processing
(NLP) tools also performing poorly on SE datasets [ 6,50,56,64]. Raman etal. created the STRUDEL
tool, an SE domain specific toxicity detector [ 73], by leveraging the PPA tool and a customized version
of Stanford’s Politeness Detector [ 25]. Sarker etal. investigated the performance of the STRUDEL tool
and four other off-the-shelf toxicity detectors on two SE datasets [ 77]. In their benchmark, none of the
tools achieved reliable performance to justify practical applications on SE datasets. However, they also
achieved encouraging performance boosts, when they retrained two of the tools (i.e., DPCNN [ 94] and
BERT with FastAI [54]) using their SE datasets.
3 RESEARCH CONTEXT
To better understand our tool design, this section provides a brief overview of the machine learning (ML)
algorithms integrated in ToxiCR and five word vectorization techniques for NLP tasks.
3.1 Supervised machine learning algorithms
For ToxiCR we selected ten supervised ML algorithms from the ones that have been commonly used for
text classification tasks. Our selection includes three classical, two ensemble methods based, four deep
neural network (DNN) based, and a Bidirectional Encoder Representations from Transformer (BERT)
based algorithms. Following subsections provide a brief overview of the selected algorithms.
3.1.1 Classical ML algorithms: We have selected the following three classical algorithms, which have been
previously used for classification of SE texts [6, 20, 55, 84, 84].
(1)Decision Tree (DT) : In this algorithm, the dataset is continuously split according to a certain
parameter. DT has two entities, namely decision nodes and leaves. The leaves are the decisions or the
final outcomes. And the decision nodes are where the data is split into two or more sub-nodes [ 71].
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.1:6•Sarker, et al.
(2)Logistic Regression (LR): LR creates a mathematical model to predict the probability for one of
the two possible outcomes and is commonly used for binary classification tasks [13].
(3)Support-Vector Machine (SVM): After mapping the input vectors into a high dimensional non-linear
feature space, SVM tries to identify the best hyperplane to partition the data into n-classes, where
n is the number of possible outcomes [24].
3.1.2 Ensemble methods: Ensemble methods create multiple models and then combine them to produce
improved results. We have selected the following two ensemble methods based algorithms, based on prior
SE studies [6, 55, 84].
(1)Random Forest (RF): RF is an ensemble based method that combines the results produced by
multiple decision trees [ 42]. RF creates independent decision trees and combines them in parallel
using on the ‘bagging’ approach [18].
(2)Gradient-Boosted Decision Trees (GBT): Similar to RF, GBT is also an ensemble based method
using decision trees [ 36]. However, GBT creates decision trees sequentially, so that each new tree can
correct the errors of the previous one and combines the results using the ‘boosting’ approach [80].
3.1.3 Deep neural networks: In recent years, DNN based models have shown significant performance
gains over both classical and ensemble based models in text classification tasks [ 52,94]. In this research,
we have selected four state-of-the-art DNN based algorithms.
(1)Long Short Term Memory (LSTM): A Recurrent Neural Network (RNN) processes inputs sequen-
tially, remembers the past, and makes decisions based on what it has learnt from the past [ 74].
However, traditional RNNs may perform poorly on long-sequence of inputs, such as those seen
in text classification tasks due to ‘the vanishing gradient problem’. This problem occurs, when a
RNN’s weights are not updated effectively due to exponentially decreasing gradients. To overcome
this limitation, Hochreiter and Schmidhuber proposed LSTM, a new type of RNN architecture,
that overcomes the challenges posed by long term dependencies using a gradient-based learning
algorithm [ 43]. LSTM consists four units: i) input gate, which decides what information to add from
current step, ii) forget gate, which decides what is to keep from prior steps, iii) output gate, which
determines the next hidden state, and iv) memory cell, stores information from previous steps.
(2)Bidirectional LSTM (BiLSTM): A BiLSTM is composed of a forward LSTM and a backward
LSTM to model the input sequences more accurately than an unidirectional LSTM [ 23,38]. In
this architecture, the forward LSTM takes input sequences in the forward direction to model
information from the past, while the backward LSTM takes input sequences in the reverse direction
to model information from the future [ 45]. BiLSTM has been shown to be performing better than
the unidirectional LSTM in several text classification tasks, as it can identify language contexts
better than LSTM [38].
(3)Gated Recurrent Unit (GRU): Similar to LSTM, GRU belongs to the RNN family of algorithms.
However, GRU aims to handle ‘the vanishing gradient problem’ using a different approach than
LSTM. GRU has a much simpler architecture with only two units, update gate and reset gate. The
reset gate decides what information should be forgot for next pass and update gate determines
which information should pass to next step. Unlike LSTM, GRU does not require any memory cell,
and therefore needs shorter training time than LSTM [31].
(4)Deep Pyramid CNN (DPCNN): Convolutional neural networks (CNN) are a specialized type of
neural networks that utilizes a mathematical operation called convolution in at least one of their
layers. CNNs are most commonly used for image classification tasks. Johnson and Zhang proposed a
special type of CNN architecture, named deep pyramid convolutional neural network (DPCNN) for
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.Automated Identification of Toxic Code Reviews Using ToxiCR •1:7
text classification tasks [ 49]. Although DPCNN achieves faster training time by utilizing word-level
CNNs to represent input texts, it does not sacrifice accuracy over character-level CNNs due to its
carefully designed deep but low-complexity network architecture.
3.1.4 Transformer model: In recent years, Transformer based models have been used for sequence
to sequence modeling such as neural machine translations. For a sequence to sequence modeling, a
Transformer architecture includes two primary parts: i) the encoder , which takes the input and generates
the higher dimensional vector representation, ii) the decoder , which generates the the output sequence
from the abstract vector from the encoder. For classification tasks, the output of encoders are used
for training. Transformers solve the ‘vanishing gradient problem’ on long text inputs using the ‘self
attention mechanism’, a technique to identify the important features from different positions of an input
sequence [87].
In this study, we select Bidirectional Encoder Representations from Transformers, which is commonly
known as BERT [ 27]. BERT based models have achieved remarkable performances in various NLP
tasks, such as question answering, sentiment classification, and text summarization [ 4,27]. BERT’s
transformer layers use multi-headed attention instead of recurrent units (e.g, LSTM, GRU) to model the
contextualized representation of each word in an input.
3.2 Word vectorization
To train an NLP model, input texts need to be converted into a vector of features that machine learning
models can work on. Bag-of-Words (BOW) is one of the most basic representation techniques, that
turns an arbitrary text into fixed-length vector by counting how many times each word appears. As
BOW representations do not account for grammar and word order, ML models trained using BOW
representations fail to identify relationships between words. On the other hand, word embedding techniques
convert words to n-dimensional vector forms in such a way that words having similar meanings have
vectors close to each other in the n-dimensional space. Word embedding techniques can be further divided
into two categories: i) context-free embedding, which creates the same representation of a word regardless
of the context where it occurs; ii) contextualized word embeddings aim at capturing word semantics
in different contexts to address the issue of polysemous (i.e., words with multiple meanings) and the
context-dependent nature of words. For this research, we have experimented with five word vectorization
techniques: one BOW based, three context-free, and one contextualized. Following subsections provide a
brief overview of those techniques.
3.2.1 Tf-Idf: TF-IDF is a BOW based vectorization technique that evaluates how relevant a word is to a
document in a collection of documents. TF-IDF score for a word is computed by multiplying two metrics:
how many times a word appears in a document ( 𝑇𝑓), and the inverse document frequency of the word
across a set of documents ( 𝐼𝑑 𝑓). Following equations show the computation steps for Tf-Idf scores.
𝑇𝑓(︀
𝑤, 𝑑)︀
=𝑓(︀
𝑤, 𝑑)︀
𝑡𝜖𝑑𝑓(︀
𝑡, 𝑑)︀
(1)
Where, 𝑓(︀
𝑡, 𝑑)︀
is the frequency of the word ( 𝑤) in the document ( 𝑑), and
𝑡𝜖𝑑𝑓(︀
𝑡, 𝑑)︀
represents the total
number of words in 𝑑. Inverse document frequency (Idf) measures the importance of a term across all
documents.
𝐼𝑑 𝑓(︀
𝑤)︀
=𝑙𝑜𝑔𝑒(︀
𝑁𝑤𝑁)︀
(2)
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.1:8•Sarker, et al.
Fig. 1. A simplified overview of ToxiCR showing key pipeline
Here, 𝑁is the total number of documents and 𝑤𝑁represents the number of documents having w. Finally,
we computed TfIdf score of a word as:
𝑇𝑓𝐼𝑑 𝑓(︀
𝑤, 𝑑)︀
=𝑇𝑓(︀
𝑤, 𝑑)︀
*𝐼𝑑 𝑓(︀
𝑤)︀
(3)
3.2.2 Word2vec: In 2013, Mikolaev etal. [58] proposed Word2vec, a context free word embedding
technique. It is based on two neural network models named Continuous Bag-of-Words (CBOW) and
Skip-gram. CBOW predicts a target word based on its context, while skip-gram uses the current word
to predict its surrounding context. During the training, word2vec takes a large corpus of text as input
and generates a vector space, where each word in the corpus is assigned a unique vector and words with
similar meaning are located close to one another.
3.2.3 GloVe: Proposed by Pennington et al. [ 68], Global Vectors for Word Representation (GloVe) is an
unsupervised algorithm to create context free word embedding. Unlike word2vec, GloVe generates vector
space from global co-occurrence of words.
3.2.4 fastText: Developed by the Facebook AI team, fastText is a simple and efficient method to generate
context-free word embeddings [ 15]. While Word2vec and GloVe cannot provide embedding for out of
vocabulary words, fastText overcomes this limitation by taking into account morphological characteristics
of individual words. A word’s vector in fastText based embedding is built from vectors of substrings of
characters contained in it. Therefore, fasttext performs better than Word2vec or GloVe in NLP tasks, if a
corpus contains unknown or rare words [15].
3.2.5 BERT:. Unlike context-free embeddings (e.g., word2vec, GloVe, and fastText), where each word
has a fixed representation regardless of the context within which the word appears, a contextualized
embedding produces word representations that are dynamically informed by the words around them. In
this study, we use BERT [27]. Similar to fastText, BERT can also handle out of vocabulary words.
4 TOOL DESIGN
Figure 1 shows the architecture of ToxiCR. It takes a text ( i.e., code review comment) as input and
applies a series of mandatory preprocessing steps. Then, it applies a series of optional preprocessing based
on selected configurations. Preprocessed texts are then fed into one of the selected vectorizers to extract
features. Finally, output vectors are used to train and validate our supervised learning-based models. The
following subsections detail the research steps to design ToxiCR.
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.Automated Identification of Toxic Code Reviews Using ToxiCR •1:9
4.1 Conceptualization of Toxicity
As we have mentioned in Section 2.1, what constitutes a ‘toxic communication’ depends on various
contextual factors. In this study, we specifically focus on popular FOSS projects such as Android,
Chromium OS, LibreOffice, and OpenStack, where participants represent diverse culture, education,
ethnicity, age, religion, gender, and political views. As participants are expected and even recommended
to maintain a high level of professionalism during their interactions with other members of those
communities [ 35,65,69], we adopt the following expansive definition of toxic contents for this context.1:
“An SE conversation will be considered as toxic, if it includes any of the following: i) offensive
name calling, ii) insults, iii) threats, iv) personal attacks, v) flirtations, vi) reference to sexual
activities, and vii) swearing or cursing.”
Our conceptualization of toxicity closely aligns with another recent work by Bhat etel. that focuses
on professional workplace communication [ 14]. According to their definition, a toxic behaviour includes
any of the following: sarcasm, stereotyping, rude statements, mocking conversations, profanity, bullying,
harassment, discrimination and violence.
4.2 Training Dataset Creation
As of May 2021, there are three publicly available labeled datasets of toxic communications from the
SE domain. Raman et al.’s dataset created for the STRUDEL tool [ 73] includes only 611 texts. In our
recent benchmark study (referred as ‘the benchmark study’ hereinafter), we created two datasets, i) a
dataset of 6,533 code review comments selected from three popular FOSS projects (referred as ‘code
review dataset 1’ hereinafter), i.e., Android, Chromium OS, and LibreOffice; ii) a dataset of 4,140 Gitter
messages selected from the Gitter Ethereum channel (referred as ‘gitter dataset’ hereinafter) [ 77]. We
followed the exact same process used in the benchmark study to select and label additional 13,038 code
review comments selected from the OpenStack projects. In the following, we briefly describe our four-step
process, which is detailed in our prior publication [77].
4.2.1 Data Mining. In the benchmark, we wrote a Python script to mine the Gerrit [61] managed code
review repositories of three popular FOSS projects, i.e., Android, Chromium OS, and LibreOffice. Our
script leverages Gerrit’s REST API to mine and store all publicly available code reviews in a MySQL
dataset. We use the same script to mine ≈2.1million code review comments belonging to 670,996 code
reviews from the OpenStack projects’ code review repository hosted at https://review.opendev.org/. We
followed an approach similar to Paul etal. [66] to identify potential bot accounts based on keywords
(e.g., ‘bot’, ‘auto’, ‘build’, ‘auto’, ‘travis’, ‘CI’, ‘jenkins’, and ‘clang’). If our manual manual validations
of comments authored by a potential bot account confirmed it to be a bot, we excluded all comments
posted by that account.
4.2.2 Stratified sampling of code review comments. Since toxic communications are rare [ 77] during code
reviews, a randomly selected dataset of code review comments will be highly imbalanced with less than
1% toxic instances. To overcome this challenge, we adopted a stratified sampling strategy as suggested
by Särndal etal. [79]. We used Google’s Perspective API (PPA) [ 7] to compute the toxicity score for
each review comment. If the PPA score is more than 0.5, then the review comment is more likely to be
toxic. Among the 2.1 million code review comments, we found 4,118 comments with PPA scores greater
than 0.5. In addition to those 4,118 review comments, we selected 9,000 code review comments with
PPA scores less than 0.5. We selected code review comments with PPA scores less than 0.5 in a well
1We introduced this definition in our prior study [ 77]. We are repeating this definition to assist better comprehension of
this paper’s context
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.1:10•Sarker, et al.
Table 2. An overview of the three SE domain specific toxicity datasets used in this study
Dataset # total texts # toxic # non-toxic
Code review 1 6,533 1,310 5,223
Code review 2 13,118 2,447 10,591
Gitter dataset 4,140 1,468 2,672
Code review (combined) 19,651 3,757 15,819
distributed manner. We split the texts into five categories (i.e, score: 0-0.1, 0.11-0.2, and so on) and took
the same amount (1,800 texts) from each category. For example, we took 1,800 samples that have a score
between 0.3 to 0.4.
4.2.3 Manual Labeling. During the benchmark study [ 77], we developed a manual labeling rubric fitting
our definition as well as study context. Our initial rubric was based on the guidelines published by
the Conversation AI Team (CAT) [ 8]. With these guidelines as our starting point, two of the authors
independently went through 1,000 texts to adopt the rules to better fit our context. Then, we had a
discussion session to merge and create a unified set of rules. Table 3 represents our final rubric that has
been used for manual labeling during both the benchmark study and this study.
Although we have used the guideline from the CAT as our starting point, our final rubric differs from
the CAT rubric in two key aspects to better fit our target SE context. First, our rubric is targeted
towards professional communities with contrast to the CAT rubric, which is targeted towards general
online communications. Therefore, profanities and swearing to express a positive attitude may not be
considered as toxic by the CAT rubric. For example, “That’s fucking amazing! thanks for sharing.” is
given as an example of ‘Not Toxic, or Hard to say’ by the CAT rubric. On the contrary, any sentence
with profanities or swearing is considered ‘toxic’ according to our rubric, since such a sentence does not
constitute a healthy interaction. Our characterization of profanities also aligns with the recent SE studies
on toxicity [ 59] and incivility [ 33]. Second, the CAT rubric is for labeling on a four point-scale (i.e., ‘Very
Toxic’, ‘Toxic’, ‘Slightly Toxic or Hard to Say’, and ‘Non toxic’) [ 1]. On the contrary, our labeling rubric
is much simpler on a binary scale (‘Toxic’ and ‘Non-toxic’), since development of four point rubric as
well as classifier is significantly more challenging. We consider development of a four point rubric as a
potential future direction.
Using this rubric, two of the authors independently labeled the 13,118 texts as either ‘toxic’ or ‘non-
toxic’. After the independent manual labeling, we compared the labels from the two raters to identify
conflicts. The two raters had agreements on 12,608 (96.1%) texts during this process and achieved a
Cohen’s Kappa ( 𝜅) score of 0.92 (i.e., an almost perfect agreement)2. We had meetings to discuss the
conflicting labels and assign agreed upon labels for those cases. At the end of conflict resolution, we found
2,447 (18.76%) texts labeled as ‘toxic’ among the 13,118 texts. We refer to this dataset as ‘code review
dataset 2’ hereinafter. Table 2 provides an overview of the three dataset used in this study.
4.2.4 Dataset aggregation. Since the reliability of a supervised learning-based model increases with the
size of its training dataset, we decided to merge the two code review dataset into a single dataset (referred
as ‘combined code review dataset’ hereinafter). We believe such merging is not problematic, due to the
following reasons.
(1) Both of the datasets are labeled using the same rubrics and following the same protocol.
2Kappa ( 𝜅) values are commonly interpreted as follows: values ≤0 as indicating ‘no agreement’ and 0.01 – 0.20 as ‘none to
slight’, 0.21 – 0.40 as ‘fair’, 0.41 – 0.60 as ‘moderate’, 0.61–0.80 as ‘substantial’, and 0.81–1.00 as ‘almost perfect agreement’.
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.Automated Identification of Toxic Code Reviews Using ToxiCR •1:11
Table 3. Rubric to label the SE text as toxic or non-toxic, adjusted from [77]
# Rule Rationale Example*
Rule 1: If a text includes profane
or curse words it would be
marked as ‘toxic’.Profanities are the most common
sources of online toxicities.fuck! Consider it
done!.
Rule 2: If a text includes an acronym,
that generally refers to exple-
tive or swearing, it would be
marked as ‘toxic’.Sometimes people use acronyms of
profanities, which are equally toxic
as their expanded form.WTF are you doing!
Rule 3: Insulting remarks regarding
another person or entities
would be marked as ‘toxic’.Insulting another developer may
create a toxic environment and
should not be encouraged....shut up, smarty-
pants.
Rule 4: Attacking a person’s identity
(e.g., race, religion, national-
ity, gender or sexual orien-
tation) would be marked as
‘toxic’.Identity attacks are considered
toxic among all categories of on-
line conversations.Stupid fucking super-
stitious Christians.
Rule 5: Aggressivebehaviororthreat-
ening another person or a
community would be marked
as ‘toxic’.Aggregations or threats may stir
hostility between two developers
and force the recipients to leave
the community.yeah, but I’d really
give a lot for an oppor-
tunity to punch them
in the face.
Rule 6: Both implicit or explicit Ref-
erences to sexual activities
would be marked as ‘toxic’.Implicit or explicit references to
sexual activities may make some
developers, particularly females,
uncomfortable and make them
leave a conversation.This code makes me
so horny. It’s beauti-
ful.
Rule 7: Flirtations would be marked
as ‘toxic’.Flirtations may also make a de-
veloper uncomfortable and make
a recipient avoid the other person
during future collaborationsI really miss you my
girl.
Rule 8: If a demeaning word (e.g.,
‘dumb’, ‘stupid’, ‘idiot’, ‘ig-
norant’) refers to either the
writer him/herself or his/her
work, the sentence would not
be marked as ‘toxic’, if it does
not fit any of the first seven
rules.It is common in SE community to
use those word for expressing their
own mistakes. In those cases, the
use of those toxic words to them-
selves or their does not make toxic
meaning. While such texts are un-
professional [ 59], those do not de-
grade future communication or col-
laboration.I’m a fool and didn’t
get the point of the
deincrement. It makes
sense now.
Rule 9: A sentence, that does not fit
rules 1 through 8, would be
marked as ‘non-toxic’.General non-toxic comments. I think ResourceWith-
Props should be there
instead of GenericRe-
source.
*Examples are provided verbatim from the datasets, to accurately represent the context. We did not
censor any text, except omitting the reference to a person’s name.
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.1:12•Sarker, et al.
Table 4. Examples of text preprocessing steps implemented in ToxiCR
Step Original Post Preprocessing
URL-rem ah crap. Not sure how I missed that.
http://goo.gl/5NFKcDah crap. Not sure how I missed that.
Cntr-exp this line shouldn’t end with a period this line should not end with a period
Sym-rem Missing: Partial-Bug: #1541928 Missing Partial Bug 1541928
Rep-elm haha...looooooooser! haha.. loser!
Adv-ptrn oh right, sh*t oh right, shit
Kwrd-rem†Thesestaticvalues should be put at the
topThese values should be put at the top
Id-split†idp = self._create_dummy_idp
(add_clean_up = False)idp = self. create dummy idp(add clean
up= False)
†– an optional SE domain specific pre-processing step
(2) We used the same set of raters for manual labeling.
(3) Both of the dataset are picked from the same type of repository (i.e., Gerrit based code reviews).
The merged code review dataset includes total 19,651 code review comments, where 3,757 comments
(19.1%) are labeled as ‘toxic’.
4.3 Data preprocessing
Code review comments are different from news, articles, books, or even spoken language. For example,
review comments often contain word contractions, URLs, and code snippets. Therefore, we implemented
eight data preprocessing steps. Five of those steps are mandatory, since those aim to remove unnecessary
or redundant features. The remaining three steps are optional and their impacts on toxic code review
detection are empirically evaluated in our experiments. Two out of the three optional pre-processing steps
are SE domain specific. Table 4 shows examples of texts before and after preprocessing.
4.3.1 Mandatory preprocessing. ToxiCR implements the following five mandatory pre-processing steps.
∙URL removal (URL-rem): A code review comment may include an URL (e.g., reference to docu-
mentation or a StackOverflow post). Although URLs are irrelevant for a toxicity classifier, they can
increase the number of features for supervised classifiers. We used a regular expression matcher to
identify and remove all URLs from our datasets.
∙Contraction expansion (Cntr-exp): Contractions, which are shortened form of one or two words, are
common among code review texts. For example, some common words are: doesn’t →does not, we’re
→we are. By creating two different lexicons of the same term, contractions increase the number
of unique lexicons and add redundant features. We replaced the commonly used 153 contractions,
each with its expanded version.
∙Symbol removal (Sym-rem): Since special symbols (e.g., &, #, and ˆ ) are irrelevant for toxicity
classification tasks, we use a regular expression matcher to identify and remove special symbols.
∙Repetition elimination (Rep-elm): A person may repeat some of the characters to misspell a toxic
word to evade detection from a dictionary based toxicity detectors. For example, in the sentence
“You’re duumbbbb!”, ‘dumb’ is misspelled through character repetitions. We have created a pattern
based matcher to identify such misspelled cases and replace each with its correctly spelled form.
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.Automated Identification of Toxic Code Reviews Using ToxiCR •1:13
∙Adversarial pattern identification (Adv-ptrn): A person may misspell profane words by replacing
some characters with a symbol (e.g., ‘f*ck’ and ‘b!tch’) or use an acronym for a slang (e.g., ‘stfu’).
To identify such cases, we have developed a profanity preprocessor, which includes pattern matchers
to identify various forms of the 85 commonly used profane words. Our preprocessor replaces each
identified case with its correctly spelled form.
4.3.2 Optional preprocessing. ToxiCR includes options to apply following three optional preprocessing
steps.
∙Identifier splitting (Id-split): In this preprocessing, we use a regular expression matcher to split
identifiers written in both camelCase and under_score forms. For example, this step will replace
‘isCrap’ with ‘is Crap’ and replace ‘is_shitty’ with ‘is shitty’. This preprocessing may help to identify
example code segments with profane words.
∙Programming Keywords Removal (Kwrd-rem): Codereviewtextsoftenincludeprogramminglanguage
specific keywords (e.g., ‘while’, ‘case’, ‘if’, ‘catch’, and ‘except’). These keywords are SE domain
specific jargon and are not useful for toxicity prediction. We have created a list of 90 programming
keywords used in the popular programming languages (e.g., C++, Java, Python, C#, PHP,
JavaScript, and Go). This step searches and removes occurrences of those programming keywords
from a text.
∙Count profane words (profane-count): Since the occurrence of profane words is suggestive of a
toxic text, we think the number of profane words in a text may be an excellent feature for a
toxicity classifier. We have created a list of 85 profane words, and this step counts the occurrences
of these words in a text. While the remaining seven pre-processing steps modify an input text
pre-vectorization, this step adds an additional dimension to the post vectored output of a text.
4.4 Word Vectorizers
ToxiCR includes option to use five different word vectorizers. However, due to the limitations of the
algorithms, each of the vectorizers can work with only one group of algorithms. In our implementation,
Tfidf works only with the classical and ensemble (CLE) methods, Word2vec, GloVe, and fastText work
with the deep neural network based algorithms, and BERT model includes its pre-trained vectorizer. For
vectorizers, we chose the following implementations.
(1)TfIdf:We select the TfidfVectorizer from the scikit-learn library. To prevent overfitting, we
discard words not belonging to at least 20 documents in the corpus.
(2)Word2vec: We select the pre-trained word2vec model available at: https://code.google.com/archive/
p/word2vec/. This model was trained with a Google News dataset of 100 billion words and contains
300-dimensional vectors for 3 million words and phrases.
(3)GloVe:Among the publicly available, pretrained GloVe models (https://github.com/stanfordnlp/
GloVe), we select the common crawl model. This model was trained using web crawl data of 820
billion tokens and contains 300 dimensional vectors for 2.2 million words and phrases.
(4)fastText: From the pretrained fastText models (https://fasttext.cc/docs/en/english-vectors.html),
we select the common crawl model. This model was trained using the same dataset as our selected
our GloVe model and contains 300 dimensional vectors for 2 million words.
(5)BERT:We select a variant of BERT model published as ‘BERT_en_uncased’. This model was
pre-trained on a dataset of 2.5 billion words from the Wikipedia and 800 million words from the
Bookcorpus [95].
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.1:14•Sarker, et al.
4.5 Architecture of the ML Models
This section discusses the architecture of the ML models implemented in ToxiCR.
4.5.1 Classical and ensemble methods. We have used the scikit-learn [ 67] implementations of the CLE
classifiers.
∙Decision Tree (DT): We have used the DecisionTreeClassifier class with default parameters.
∙Logistic Regression (LR): We have used the LogisticRegression class with default parameters.
∙Support-Vector Machine (SVM): Among the various SVM implementations offered by scikit-learn,
we have selected the LinearSVC class with default parameters.
∙Random Forest (RF): We have used the RandomForestClassifier class from scikit-learn ensembles.
To prevent overfitting, we set the minimum number of samples to split at to 5. For the other
parameters, we accepted the default values.
∙Gradient-Boosted Decision Trees (GBT): We have used the GradientBoostingClassifier class
from the scikit-learn library. We set n_iter_no_change =5, which stops the training early if the
last 5 iterations did not achieve any improvement in accuracy. We accepted the default values for
the other parameters.
4.5.2 Deep Neural Networks Model. We used the version 2.5.0 of the TensorFlow library [ 3] for training
the four deep neural network models (i.e., LSTM, BiLSTM, GRU, and DPCNN).
Common parameters of the four models are:
∙We setmax_features = 5000 (i.e., maximum number of features to use) to reduce the memory
overhead as well as to prevent model overfitting.
∙Maximum length of input is set to 500, which means our models can take texts with at most 500
words as inputs. Any input over this length would be truncated to 500 words.
∙As all the three pre-trained word embedding models use 300 dimensional vectors to represent words
and phrases, we have set embedding size to 300.
∙The embedding layer takes input embedding matrix as inputs. Each of word ( 𝑤𝑖) from a text is
mapped (embedded) to a vector ( 𝑣𝑖) using one of the three context-free vectorizers (i.e., fastText,
GloVe, and word2vec). For a text 𝑇, its embedding matrix will have a dimension of 300𝑋𝑛, where
𝑛is the total number of words in that text.
∙Since we are developing binary classifiers, we have selected binary_crossentropy loss function for
model training.
∙We have selected the Adam optimizer (Adaptive Moment Estimation) [ 51] to update the weights
of the network during the training time. The initial learning_rate is set to 0.001.
∙During the training, we set accuracy (𝐴) as the evaluation metric.
The four deep neural models of ToxiCR are primarily based on three layers as described briefly in the
following. Architecture diagrams of the models are included in our replication package [76].
∙Input Embedding Layer: After preprocessing of code review texts, those are converted to input
matrix. Embedded layer maps input matrix to a fixed dimension input embedding matrix. We
used three pre-trained embeddings which help the model to capture the low level semantics using
position based texts.
∙Hidden State Layer: This layer takes the position wise embedding matrix and helps to capture the
high level semantics of words in code review texts. The configuration of this layer depends on the
choice of the algorithm. ToxiCR includes one CNN (i.e., DPCNN) and three RNN (i.e., LSTM,
BiLSTM, GRU) based hidden layers. In the following, we describe the key properties of these four
types of layers.
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.Automated Identification of Toxic Code Reviews Using ToxiCR •1:15
–DPCNN blocks: Following the implementation of DPCNN [ 49], we set 7 convolution blocks with
Conv1Dlayer after the input embedding layer. We also set the other parameters of DPCNN model
following [ 49]. Outputs from each of the CNN blocks is passed to a GlobalMaxPooling1D layer to
capture the most important features from the inputs. A dense layer is set with 256 units which is
activated with a linear activation function.
–LSTM blocks: From the Keras library, we use LSTMunit to capture the hidden sequence from
input embedding vector. LSTM unit generates the high dimensional semantic representation
vector. To reshape the output dimension, we use flatten and dense layer after LSTM unit.
–BiLSTM blocks: For text classification tasks, BiLSTM works better than LSTM for capturing the
semantics of long sequence of text. Our model uses 50 units of Bidirectional LSTM units from
the Keras library to generate the hidden sequence of input embedding matrix. To downsample
the high dimension hidden vector from BiLSTM units, we set a GlobalMaxPool1D layer. This
layer downsamples the hidden vector from BiLSTM layer by taking the maximum value of each
dimension and thus captures the most important features for each vector.
–GRU blocks: We use bidirectional GRUs with 80 units to generate the hidden sequence of input
embedding vector. To keep the most important features from GRU units, we set a concatenation
ofGlobalAveragePooling1D andGlobalMaxPooling1D layers.GlobalAveragePooling1D calcu-
lates the average of entire sequence of each vector and GlobalMaxPooling1D finds the maximum
value of entire sequence.
∙Classifier Layer: The output vector of hidden state layer project to the output layer with a dense
layer and a sigmoid activation function. This layer generates the probability of the input vector
from the range 0 to 1. We chose a sigmoid activation function because it provides the probability
of a vector within 0 to 1 range.
4.5.3 Transformer models. Among the several pre-trained BERT models3we have used bert_en_uncased ,
which is also known as the 𝐵𝐸𝑅𝑇_𝑏𝑎𝑠𝑒model. We downloaded the models from the tensorflow_hub ,
which consists trained machine learning models ready for fine tuning.
Our BERT model architecture is as following:
∙Input layer: takes the preprocessed input text from our SE dataset. To fit into BERT pretrained en-
coder,wepreprocesseachtextusingmatchingpreprocessingmodel(i.e. bert_en_uncased_preprocess
4).
∙BERT encoder: From each preprocessed text, this layer produces BERT embedding vectors with
higher level semantic representations.
∙Dropout Layer: To prevent overfitting as well as eliminate unnecessary features, outputs from the
BERT encoder layer is passed to a dropout layer with a probability of 0.1 to drop an input.
∙Classifier Layer: Outputs from the dropout layer is passed to a two-unit dense layer, which transforms
the outputs into two-dimensional vectors. From these vectors, a one-unit dense layer with linear
activation function generates the probabilities of each text being toxic. Unlike deep neural network’s
output layer, we have found that linear activation function provides better accuracy than non-linear
ones (e.g, 𝑟𝑒𝑙𝑢,𝑠𝑖𝑔𝑚𝑜𝑖𝑑) for the BERT-based models.
∙Parameters: Similar to the deep neural network models, we use binary_crossentropy as the loss
function and Binary Accuracy as the evaluation metric during training.
3https://github.com/google-research/bert
4https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.1:16•Sarker, et al.
Table 5. An overview of the hyper parameters for our deep neural networks and transformers
Hyper-Parameters Deep neural networks (i.e., DPCNN,
LSTM, BiLSTM, and GRU)Transformer (BERT)
Activation sigmoid linear
Loss function binary crossentropy binary crossentropy
Optimizer adam Adamw
Learning rate 0.001 3e-5
Early stopping monitor val_loss val_loss
Epochs 40 15
Batch size 128 256
∙Optimizer: We set the optimizer as Adamw[57] which improved the generalization performance of
‘adam’ optimizer. Adamwminimizes the prediction loss and does regularization by decaying weight.
Following the recommendation of Devlin etal. [27], we set the initial learning rate to 3𝑒−5.
4.6 Model Training and Validation
Following subsections detail our model training and validation approaches.
4.6.1 Classical and ensembles. We evaluated all the models using 10-fold cross validations, where the
dataset was randomly split into 10 groups and each of the ten groups was used as test dataset once, while
the remaining nine groups were used to train the model. We used stratified split to ensure similar ratios
of the classes between the test and training sets.
4.6.2 DNN and Transformers. We have customized several hyper-parameters of the DNN models to train
our models. Table 5 provides an overview of those customized hyper-parameters. A DNN model can be
overfitted due to over training. To encounter that, we have configured our training parameters to find the
best fit model that is not overfitted. During training, we split our dataset into three sets according to
8:1:1 ratio. These three sets are used for training, validation, and testing respectively during our 10-fold
cross validations to evaluate our DNN and transformer models. For training, we have set maximum 40
epochs5for the DNN models and maximum 15 epochs for the BERT model. During each epoch, a model
is trained using 80% samples, is validated using 10% samples, and the remaining 10% is used to measure
the performance of the trained model. To prevent overfitting, we have used an EarlyStopping function
from the Keras library, which monitors minimum val loss . If the performance of a model on the validation
dataset starts to degrade (e.g. loss begins to increase or accuracy begins to drop), then the training
process is stopped.
4.7 Tool interface
We have designed ToxiCR to support standalone evaluation as well as being used as a library for toxic
text identification. We have also included pre-trained models to save model training time. Listing 1 shows
a sample code to predict the toxicity of texts using our pretrained BERT model.
We have also included a command line based interface for model evaluation, retraining, and fine tuning
hyperparameters. Figure 2 shows the usage help message of ToxiCR. Users can customize execution with
eight optional parameters, which are as follows:
5the number times that a learning algorithm will work through the entire training dataset
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.Automated Identification of Toxic Code Reviews Using ToxiCR •1:17
Fig. 2. The command line interface of ToxiCR showing various customization options
1from ToxiCR import ToxiCR
2
3clf=ToxiCR(ALGO="BERT" , count_profanity=False , remove_keywords=True ,
4 split_identifier=False ,
5 embedding="bert" , load_pretrained=True)
6
7clf . init_predictor ()
8sentences=[" this is crap" , "thank you for the information" ,
9 " shi ∗tty code" ]
10
11results=clf . get_toxicity_class(sentences)
Listing 1. Example usage of ToxiCR to classify toxic texts
∙Algorithm Selection: Users can select one of the ten included algorithms by using the –algo ALGO
option.
∙Number of Repetitions: Users can specify the number of times to repeat the 10-fold cross-validations
in evaluation mode using –repeat n option. Default value is 5.
∙Embedding: ToxiCR includes five different vectorization techniques: tfidf,word2vec ,glove,
fasttext , andbert.tfidfis configured to be used only with the CLE models. word2vec ,glove,
andfastext can be used only with the DNN models. Finally, bertcan be used only with the
transformer model. Users can customize this selection using the –embed EMBED option.
∙Identifier splitting: Using the –splitoption, users can select to apply the optional preprocessing
step to split identifiers written in camelCases or under_scores.
∙Programming keywords: Using the –keyword option, users can select to apply the optional prepro-
cessing step to remove programming keywords.
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.1:18•Sarker, et al.
∙Profanity: The –profanity optional preprocessing step allows to add the number of profane words
in a text as an additional feature.
∙Missclassification diagnosis: The –retrooption is useful for error diagnosis. If this option is selected,
ToxiCR will write all misclassified texts in a spreadsheet to enable manual analyses.
∙Execution mode: ToxiCR can be executed in three different modes. The evalmode will run 10-fold
cross validations to evaluate the performance of an algorithm with the selected options. In the eval
mode, ToxiCR writes results of each run and model training time in a spreadsheet. The retrain
mode will train a classifier with the full dataset. This option is useful for saving models in a file to be
used in the future. Finally, the tuningmode allows to explore various algorithm hyperparameters
to identify the optimum set.
5 EVALUATION
We empirically evaluated the ten algorithms included in ToxiCR to identify the best possible configuration
to identify toxic texts from our datasets. Following subsections detail our experimental configurations
and the results of our evaluations.
5.1 Experimental Configuration
To evaluate the performance of our models, we use precision, recall, f-score, accuracy for both toxic (class
1) and non-toxic (class 0) classes. We computed the following evaluation metrics.
∙Precision ( 𝑃):For a class, precision is the percentage of identified cases that truly belongs to that
class.
∙Recall ( 𝑅):For a class, recall is the ratio of correctly predicted cases and total number of cases.
∙F1-score ( 𝐹1):F1-score is the harmonic mean of precision and recall.
∙Accuracy ( 𝐴):Accuracy is the percentage of cases that a model predicted correctly.
In our evaluations, we consider F1-score for the toxic class (i.e., 𝐹11) as the most important metric to
evaluate these models, since: i) identification of toxic texts is our primary objective, and ii) our datasets
are imbalanced with more than 80% non-toxic texts.
To estimate the performance of the models more accurately, we repeated 10-fold cross validations
five times and computed the means of all metrics over those 5 *10 =50 runs. We use Python’s Random
module, which is a pseudo-random number generator, to create stratified 10-fold partitions, preserving
the ratio between the two classes across all partitions. If initialized with the same seed number, Random
would generate the exact same sequence of pseudo-random numbers. At the start of each algorithm’s
evaluation, we initialized the Randomgenerator using the same seed to ensure the exact same sequence
of training/testing partitions for all algorithms. As the model performances are normally distributed,
we use paired sample t-tests to check if observed performance differences between two algorithms are
statistically significant ( 𝑝 < 0.05). We use the ‘paired sample t-test’, since our experimental setup
guarantees cross-validation runs of two different algorithms would get the same sequences of train/test
partitions. We have included the results of the statistical tests in the replication package [76].
We conducted all evaluations on an Ubuntu 20.04 LTS workstation with Intel i7-9700 CPU, 32GB
RAM, and an NVIDIA Titan RTX GPU with 24 GB memory. For python configuration, we created an
Anaconda environment with Python 3.8.0, and tensorflow /tensorflow-gpu 2.5.0.
5.2 Baseline Algorithms
To establish baseline performances, we computed the performances of four existing toxicity detectors
(Table 6) on our dataset. We briefly describe the four tools in the following.
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.Automated Identification of Toxic Code Reviews Using ToxiCR •1:19
Table6. Performancesofthefourcontemporarytoxicdetectorstoestablishabaselineperformance.Forourclassifications,
we consider toxic texts as the ‘class 1’ and non-toxic texts as the ‘class 0’.
ModelsNon-toxic ToxicAccuracy𝑃0𝑅0𝐹10 𝑃1𝑅1𝐹11
Perspective API [7] (off-the-shelf) 0.920.790.850.450.700.55 0.78
Strudel Tool (off-the-shelf) [73] 0.930.760.830.430.770.55 0.76
Strudel (retrain) [78] 0.970.960.970.850.860.85 0.94
DPCNN (retrain) [77] 0.940.950.940.810.760.78 0.91
(1)Perspective API [ 7] (off-the-shelf): To prevent the online community from abusive content, Jigsaw
and Google’s Counter Abuse Technology team developed Perspective API [ 7]. Algorithms and
datasetstotrainthesemodelsarenotpubliclyavailable.PerspectiveAPIcangeneratetheprobability
score of a text being toxic, servere_toxic, insult, profanity, threat, identity_attack, and sexually
explicit. The score for each category is from 0 to 1 where the probability of a text belonging to that
category increases with the score. For our two class classification, we considered a text as toxic if its
Perspective API score for the toxicity category is higher than 0.5.
(2)STRUDEL tool [ 73] (off-the-shelf): The STRUDEL tool is an ensemble based on two existing tools:
Perspective API and Stanford politeness detector and BoW vector obtained from preprocessed
text. Its classification pipeline obtains toxicity score of a text using the Perspective API, computes
politeness score using the Stanford politeness detector tool [ 25], and computes BoW vector using
TfIdf. For SE specificity, its TfIdf vectorizer excludes words that occur more frequently in the SE
domain than in a non-SE domain. Although, STRUDEL tool also computes several other features
such as sentiment score, subjectivity score, polarity score, number of LIWC anger words, and the
number of emoticons in a text, none of these features contributed to improved performances during
its evaluation [ 73]. Hence, the best performing ensemble from STRUDEL uses only the Perspective
API score, Stanford politeness score, and TfIdf vector. The off-the-shelf version is trained on a
manually labeled dataset of 654 Github issues.
(3)STRUDEL tool [ 78] (retrain): Due to several technical challenges, we were unable to retrain
the STRUDEL tool using the source code provided in its repository [ 73]. Therefore, we wrote a
simplified re-implementation based on the description included in the paper and our understanding
of the current source code. Upon contacting, the primary author of the tool acknowledged our
implementation as correct. Our implementation is publicly available inside the WSU-SEAL directory
of the publicly available repository: https://github.com/WSU-SEAL/toxicity-detector. Our pull
request with this implementation has been also merged to the original repository. For computing
baseline performance, we conducted a stratified 10-fold cross validation using our code review
dataset.
(4)DPCNN [ 77] (retrain): We cross-validated a DPCNN model [ 49], using our code review dataset.
We include this model in our baseline, since it provided the best retrained performance during our
benchmark study [77].
Table 6 shows the performances of the four baseline models. Unsurprisingly, the two retrained models
provide better performances than the off-the-shelf ones. Overall, the retrained Strudel tool provides
the best scores among the four tools on all seven metrics. Therefore, we consider this model as the key
baseline to improve on. The best toxicity detector among the ones participating in the 2020 SemEval
challenge achieved 0.92 𝐹1score on the Jigsaw dataset [ 91]. As the baseline models listed in Table 6 are
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.1:20•Sarker, et al.
Table 7. Mean performances of the ten selected algorithms based on 10-fold cross validations. For each group, shaded
background indicate significant improvements over the others from the same group
Group Models VectorizerNon-toxic ToxicAccuracy ( 𝐴)𝑃0 𝑅0 𝐹10 𝑃1 𝑅1 𝐹11
CLEDT tfidf 0.9540.9630.9590.8410.8060.823 0.933
GBT tfidf 0.9260.9850.9550.9160.6720.775 0.925
LR tfidf 0.9180.9830.9490.9000.6330.743 0.916
RF tfidf 0.9560.9820.9690.9160.8100.859 0.949
SVM tfidf 0.9290.9790.9540.8880.6880.775 0.923
DNN1DPCNN word2vec 0.9620.9660.9640.8700.8410.849 0.942
DPCNN GloVe 0.9630.9660.9640.8710.8420.851 0.943
DPCNN fasttext 0.9640.9670.9650.8700.8450.852 0.944
DNN2LSTM word2vec 0.9290.9780.9530.8660.6980.778 0.922
LSTM GloVe 0.9440.9710.9570.8640.7580.806 0.930
LSTM fasttext 0.9360.9740.9540.8530.7180.778 0.925
DNN3BiLSTM word2vec 0.9650.9740.9690.8870.8510.868 0.950
BiLSTM GloVe 0.9650.9760.9680.8950.8280.859 0.948
BiLSTM fasttext 0.9660.9740.9700.8880.8540.871 0.951
DNN4GRU word2vec 0.9640.9760.9700.8940.8470.870 0.951
GRU GloVe 0.9650.9770.9710.9010.8510.875 0.953
GRU fasttext 0.9650.9740.9690.8880.8520.869 0.951
Transformer BERT en uncased 0.9710.9760.9730.9010.8760.887 0.957
evaluated on a different dataset, it may not be fair to compare these models against the ones trained on
Jigsaw dataset. However, the best baseline model’s 𝐹1score is 7 (i.e., 0.92 -0.85 ) points lower than the
ones from a non-SE domain. This result suggests that with existing technology, it may be possible to train
SE domain specific toxicity detectors with better performances than the best baseline listed in Table 6.
Finding 1: Retrained models provide considerably better performances than the off-the-shelf ones,
with the retrained STRUDEL tool providing the best performances. Still the 𝐹11score from the best
baseline model lags 7 points behind the 𝐹11score of state-of-the-art models trained and evaluated on
the Jigsaw dataset during 2020 SemEval challenge [91].
5.3 How do the algorithms perform without optional preprocessing?
Following subsections detail the performances of the three groups of algorithm described in the Section 4.5.
5.3.1 Classical and Ensemble (CLE) algorithms. The top five rows of the Table 7 (i.e., CLE group) show
the performances of the five CLE models. Among, those five algorithms, RF achieves significantly higher
𝑃0(0.956), 𝐹10(0.969), 𝑅1(0.81), 𝐹11(0.859) and accuracy (0.949) than the four other algorithms
from this group. The RF model also significantly outperforms (One-sample t-test) the key baseline (i.e.,
retrained STRUDEL) in terms of the two key metrics, accuracy ( 𝐴) and 𝐹11. Although, STRUDEL
retrain achieves better recall ( 𝑅1), our RF based model achieves better precision ( 𝑃1).
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.Automated Identification of Toxic Code Reviews Using ToxiCR •1:21
5.3.2 Deep Neural Networks (DNN). We evaluated each of the four DNN algorithms using three different
pre-trained word embedding techniques (i.e., word2vec, GloVe, and fastText) to identify the best per-
forming embedding combinations. Rows 6 to 17 (i.e., groups: DNN1, DNN2, DNN3, and DNN4) of the
Table 7 show the performances of the four DNN algorithms using three different embeddings. For each
group, statistically significant improvements (paired-sample t-tests) over the other two configurations
are highlighted using shaded background. Our results suggest that choice of embedding does influence
performances of the DNN algorithms. However, such variations are minor.
For DPCNN, only 𝑅1score is significantly better with fastText than it is with GloVe or word2vec. The
other scores do not vary significantly among the three embeddings. Based on these results, we recommend
fastText for DPCNN in ToxiCR. For LSTM and GRU, GloVe boosts significantly better 𝐹11scores than
those based on fastText or word2vec. Since 𝐹11is one of the key measures to evaluate our models, we
recommend the GloVe for both LSTM and GRU in ToxiCR. Glove also boosts the highest accuracy
for both LSTM (although not statistically significant) and GRU. For BiLSTM, since fastText provides
significantly higher 𝑃0,𝑅1, and 𝐹11scores than those based on GloVe or word2vec. We recommend
fastText for BiLSTM in ToxiCR. These results also suggest that three out of the four selected DNN
algorithms (i.e., except LSTM) significantly outperform (one-sample t-test) the key baseline (i.e., retrained
STRUDEL) in terms of both accuracy and 𝐹11-score.
5.3.3 Transformer. The bottom row of Table 7 shows the performance of our BERT based model. This
model achieves the highest mean accuracy (0.957) and 𝐹11(0.887) among all the 18 models listed in
Table 7. This model also outperforms the baseline STRUDEL retrain on all the seven metrics.
Finding 2: From the CLE group, RF provides the best performances. From the DNN group GRU with
glove provides the best performances. Among the 18 models from the six groups, BERT achieves the
best performances. Overall, ten out of the 18 models also outperform the baseline STRUDEL retrain
model.
5.4 Do optional preprocessing steps improve performance?
For each of the ten selected algorithms, we evaluated whether the optional preprocessing steps (especially
SE domain specific ones) improve performances. Since ToxiCR includes three optional preprocessing (i.e.,
identifier splitting ( id-split), keyword removal ( kwrd-remove ), and counting profane words ( profane-count ),
we ran each algorithm with 23=8different combinations. For the DNN models, we did not evaluate all
three embeddings in this step, as that would require evaluating 3*8= 24 possible combinations for each one.
Rather we used only the best performing embedding identified in the previous step (i.e., Section 5.3.2).
To select the best optional preprocessing configuration from the eight possible configurations, we use
mean accuracy and mean 𝐹11scores based on five time 10-fold cross validations. We also used pair
sampled t-tests to check whether any improvement over its base configuration’s, as listed in the Table 7
(i.e., no optional preprocessing selected), is statistical significant ( paired sample t-test, 𝑝 <0.05).
Table 8 shows the best performing configurations for all algorithms and the mean scores for those
configurations. Checkmarks ( ✓) in the preprocessing columns for an algorithm indicate that the best
configuration for that algorithm does use that pre-processing. To save space, we report the performances of
only the best combination for each algorithm. Detailed results are available in our replication package [ 76].
These results suggest that optional pre-processing steps do improve the performances of the models.
Notably, CLE models gained higher improvements than the other two groups. RF’s accuracy improved
from 0.949 to 0.955 and 𝐹11improved from 0.859 to 0.879 with the profane-count preprocessing.
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.1:22•Sarker, et al.
Table 8. Best performing configurations of each model with optional preprocessing steps. Shaded background indicates significant improvements
over its base configuration (i.e., no optional preprocessing). For each column, bold font indicates the highest value for that measure. †– indicates
an optional SE domain specific pre-processing step.
Group Algo VectorizerPreprocessing Non-toxic Toxic𝐴profane-
countkwrd-
removeid-
split𝑃0 𝑅0 𝐹10 𝑃1 𝑅1 𝐹11
CLEDT tfidf ✓ ✓ -0.9600.9680.9640.862 0.8300.845 0.942
GBT tfidf ✓ ✓ -0.9380.9810.9590.901 0.7290.806 0.932
LR tfidf ✓ ✓ -0.9320.9810.9560.898 0.6980.785 0.927
RF tfidf ✓ - -0.9640.9810.9720.917 0.8450.879 0.955
SVM tfidf ✓ ✓ -0.9390.9770.9580.886 0.7360.804 0.931
DNNDPCNN fasttext ✓ - -0.9640.9730.9680.889 0.8460.863 0.948
LSTM glve ✓ ✓ ✓0.9440.9740.9590.878 0.7560.810 0.932
BiLSTM fasttext ✓ - ✓0.9660.9750.9710.892 0.8580.875 0.953
BiGRU glove ✓ - ✓0.9660.9760.9710.897 0.8560.876 0.954
Transormer BERT bert - ✓ -0.9700.9780.9740.907 0.8740.889 0.958
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.Automated Identification of Toxic Code Reviews Using ToxiCR •1:23
Table 9. Performance of ToxiCR on Gitter dataset
Mode Models VectorizerNon-toxic ToxicAccuracy𝑃 𝑅 𝐹1 𝑃 𝑅 𝐹1
Cross-validation
(retrain)RF TfIdf 0.8510.9450.8970.8790.6990.779 0.859
BERT BERT-en-uncased 0.9310.9090.9190.8430.8770.856 0.898
Cross-prediction
(off-the-shelf)RF TfIdf 0.8570.9770.9140.9450.7040.807 0.881
BERT BERT-en-uncased 0.8970.9490.9230.8970.8020.847 0.897
During these evaluations, other CLE models also achieved between 0.02 to 0.04 performance boosts in
our key measures (i.e., 𝐴and𝐹11). Improvements from optional preprocessing also depend on algorithm
choices. While the profane-count preprocessing improved performances of all the CLE models, kwrd-remove
improved all except RF. On the other hand, id-splitimproved none of the CLE models.
All the DNN models also improved performances with the profane-count preprocessing. Contrasting
the CLE models, id-splitwas useful for three out of the four DNNs. kwrd-remove preprocessing improved
only LSTM models. Noticeably, gains from optional preprocessing for the DNN models were less than
0.01 over the base configurations’ and statistically insignificant (paired-sample t-test, 𝑝 >0.05) for most
of the cases. Finally, although we noticed slight performance improvement (i.e., in 𝐴and𝐹11) of the
BERT model with kwrd-remove , the differences are not statistically significant. Overall, at the end of our
extensive evaluation, we found the best performing combination was a BERT model with kwrd-remove
optional preprocessing. The best combination provides 0.889 𝐹11score and 0.958 accuracy. The best
performing model also significantly outperforms (one sample t-test, 𝑝 < 0.05) the baseline model (i.e,
STRUDEL retrain in Table 6) in all the seven performance measures.
Finding3: Eight out of the ten models (i.e., except SVM and DPCNN) achieved significant performance
gains through SE domain preprocessing such as programming keyword removal and identifier splitting.
Although keyword removal may be useful for all the four classes of algorithms, identifier splitting is
useful only for three DNN models. Our best model is based on BERT, which significantly outperforms
the STRUDEL retrain model on all seven measures.
5.5 How do the models perform on another dataset?
To evaluate the generality of our models, we have used the Gitter dataset of 4,140 messages from our
benchmark study [ 77]. In this step, we conducted two types of evaluations. First, we ran 10-fold cross
validations of the top CLE model (i.e., RF) and the BERT model using the Gitter dataset. Second, we
evaluated cross dataset prediction performance (i.e., off-the-shelf) by using the code review dataset for
training and the Gitter dataset for testing.
The top two rows of the Table 9 shows the results of 10-fold cross-validations for the the two models.
We found that the BERT model provides the best accuracy (0.898) and the best 𝐹11(0.856). On the
Gitter dataset, all the seven performance measures achieved by the BERT model are lower than those
on the code review dataset. It may be due to the smaller size of the Gitter dataset (4,140 texts) than
the code review dataset (19,651 texts). The bottom two rows of the Table 9 shows the results of our
cross-predictions (i.e., off-the-shelf). Our BERT model achieved similar performances in terms of 𝐴and
𝐹11in both modes. However, the RF model performed better on the Gitter dataset in cross-prediction
mode (i.e., off-the-shelf) than in cross-validation mode. This result further supports our hypothesis that
the performance drops of our models on the Gitter dataset may be due to smaller sized training data.
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.1:24•Sarker, et al.
Table 10. Confusion Matrix for our best performing model (i.e., BERT) for the combined code review dataset
Predicted
ToxicNon-toxic
ActualToxic 3259 483
Non-toxic 373 15,446
Finding 4: Although, our best performing model provides higher precision off-the-shelf on the Gitter
dataset than that from the retrained model, the later achieves better recall. Regardless, our BERT
model achieves similar accuracy and 𝐹11during both off-the-shelf usage and retraining.
5.6 What are the distributions of misclassifications from the best performing model?
The best-performing model (i.e., BERT) misclassified only 856 texts out of the 19,651 texts from our
dataset. There are 373 false positives and 483 false negatives. Table 10 shows the confusion matrix of the
BERT model. To understand the reasons behind misclassifications, we adopted an open coding approach
where two of the authors independently inspected each misclassified text to identify general scenarios.
Next, they had a discussion session, where they developed an agreed upon higher level categorization
scheme of five groups. With this scheme, those two authors independently labeled each misclassified text
into one of those five groups. Finally, they compared their labels and resolved conflicts through mutual
discussions.
False negative False positive
0.0%10.0%20.0%30.0%40.0%MissclassificationsError categories
Confunding contexts
Bad acronym
Self deprecation
SE domain specific words
General error
Fig. 3. Distribution of the misclassifications from the BERT model
Figure 3 shows distributions of the five categories of misclassifcations from ToxiCR grouped by False
Positives (FP) and False Negatives (FN). Following subsections detail those error categories.
5.6.1 General erros (GE). General errors are due to failures of the classifier to identify the pragmatic
meaning of various texts. These errors represent 45% of the false positives and 46% of the false negatives.
Many GE false positives are due to words or phrases that more frequently occur in toxic contexts and
vice versa. For example, “If we do, should we just get rid of the HBoundType?” and“Done. I think they
came from a messed up rebase.” are two false positive cases, due to the phrases ‘get rid of’ and ‘messed
up’ that have occurred more frequently in toxic contexts.
GE errors also occurred due to infrequent words. For example, “"Oh, look. The stupidity that makes
me rant so has already taken root. I suspect it’s not too late to fix this, and fixing this rates as a mitzvah
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.Automated Identification of Toxic Code Reviews Using ToxiCR •1:25
in my book." – is incorrectly predicted as non-toxic as a very few texts in our dataset include the word
‘stupidity’. Another such instance was “this is another instance of uneducated programmers calling any
kind of polymorphism overloading, please translate it to override.” , due to to word ‘uneducated’. As we did
not have many instances of identify attacks in our dataset, most of those were also incorrectly classified.
For example, “most australian dummy var name ever!" was predicted as non-toxic by our classifier.
5.6.2 SE domain specific words (SE):. Words that have different meanings in the SE domain than its’
meaning in the general domain (die, dead, kill, junk, and bug) [ 77] were responsible for 40% false positives
and 43% false negatives. For example, the text “you probably wanted ‘die‘ here. eerror is not fatal.” ,
is incorrectly predicted as toxic due to the presence of the words ‘die’ and ‘fatal’. On the other hand,
although the word ‘junk’ is used to harshly criticize a code in the sentence “I don’t actually need all this
junk...”, this sentence was predicted as non-toxic as most of the code review comments from our dataset
do not use ‘junk’ in such a way.
5.6.3 Self deprecation (SD):. Usage of self-deprecating texts to express humility is common during code
reviews [59,77]. We found that 13% of 373 false positives and 11% of 493 false negatives were due to the
presence of self deprecating phrases. For example, “ Missing entry in kerneldoc above... (stupid me) ” is
labeled as ‘non-toxic’ in our dataset but is predicted as ‘toxic’ by our model. Although, our model did
classify many of the SD texts expressing humbleness correctly, those texts also led to some false negatives.
For example, although “ Huh? Am I stupid? How’s that equivalent? ” was misclassified as non-toxic, it fits
‘toxic’ according to our rubric due to its aggressive tone.
5.6.4 Bad acronym (BA). In few cases, developers have used acronyms with with alternate toxic expansion.
For example, the webkit framework used the acronym ‘WTF’ -‘Web Template Framework’6, for a
namespace. Around 2% of our false positive cases were comments referring to the ‘WTF’ namespace from
Webkit.
5.6.5 Confounding contexts (CC). Some of the texts in our dataset represent confounding contexts and
were challenging even for the human raters to make a decision. Such cases represent 0.26% false positives
and 1.04% false negatives. For example, “This is a bit ugly, but this is what was asked so I added a null
ptr check for |inspector_agent_|. Let me know what you think.” is a false positive case from our dataset.
We had labeled it as non-toxic, since the word ‘ugly’ is applied to critique code written by the author
of this text. On the other hand, “I just know the network stack is full of _bh poop. Do you ever get
called from irq context? Sorry, I didn’t mean to make you thrash.” is labeled as toxic due to thrashing
another person’s code with the word ‘poop’. However, the reviewer also said sorry in the next sentence.
During labeling, we considered it as toxic, since the reviewer could have critiqued the code in a nicer way.
Probably due to the presence of mixed contexts, our classifier incorrectly predicted it as ‘non-toxic’.
Finding 5: Almost 85% of the misclassifications are due to either our model’s failure to accurately
comprehend the pragmatic meaning of a text (i.e., GE) or words having SE domain specific synonyms.
6 IMPLICATIONS
Based on our design and evaluation of ToxiCR, we have identified following lessons.
Lesson 1: Development of a reliable toxicity detector for the SE domain is feasible. Despite of creating
an ensemble of multiple NLP models (i.e., Perspective API, Sentiment score, Politeness score, Subjectivity,
and Polarity) and various categories of features (i.e., BoW, number of anger words, and emoticons), the
6https://stackoverflow.com/questions/834179/wtf-does-wtf-represent-in-the-webkit-code-base
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.1:26•Sarker, et al.
STRUDEL tool achieved only 0.57 F-score during their evaluation. Moreover, a recent study by Miller
etal. found false positive rates as high as 98% [ 59]. On the other hand, the best model from the ‘2020
Semeval Multilingual Offensive Language Identification in Social Media task’ achieved a 𝐹11score of
92.04% [92]. Therefore, the question remains, whether we can build a SE domain specific toxicity detector
that achieves similar performances (i.e., 𝐹1=0.92) as the ones from non-SE domains.
In designing ToxiCR, we adopted a different approach, i.e., focusing on text preprocessing and leveraging
state-of-the-art NLP algorithms rather than creating ensembles to improve performances. Our extensive
evaluation with a large scale SE dataset has identified a model that has 95.8% accuracy and boosts 88.9%
𝐹11score in identifying toxic texts. This model’s performances are within 3% of the best one from a
non-SE domain. This result also suggests that with a carefully labeled large scale dataset, we can train
an SE domain specific toxicity detector that achieves performances that are close to those of toxicity
detectors from non-SE domains.
Lesson 2: Performance from Random Forest’s optimum configuration may be adequate if GPU is not
available.
While a deep learning-based model (i.e., BERT) achieved the best performances during our evaluations,
that model is computationally expensive. Even with a high end GPU such as Titan RTX, our BERT
model required on average 1,614 seconds for training. We found that RandomForest based models trained
on a Core-i7 CPU took only 64 seconds on average.
During a classification task, RF generates the decision using majority voting from all sub trees. RF is
suitable for high dimensional noisy data like the ones found in text classification tasks [ 47]. With carefully
selected preprocessing steps to better understand contexts (e.g., profanity count) RF may perform well
for binary toxicity classification tasks. In our model, after adding profane count features, RF achieved an
average accuracy of 95.5% and 𝐹11- score of 87.9%, which are within 1% of those achieved by BERT.
Therefore, if computation cost is an issue, a RandomForest based model may be adequate for many
practical applications. However, as our RF model uses a context-free vectorizer, it may perform poorly
on texts, where prediction depends on surrounding contexts. Therefore, for a practical application, a user
must take that limitation into account.
Lesson 3: Preprocessing steps do improve performances.
We have implemented five mandatory and three optional preprocessing steps in ToxiCR. The mandatory
preprocessing steps do improve performances of our models. For example, a DPCNN model without these
preprocessing achieved 91% accuracy and 78% 𝐹11(Table 6). On the other hand, a model based on the
same algorithm achieved 94.4% accuracy and 84.5% 𝐹11with these preprocessing steps. Therefore, we
recommend using both domain specific and general preprocessing steps.
Two of our pre-processing steps are SE domain specific (i.e., Identifier Splitting, Programming Keywords
removal). Our empirical evaluation of those steps (Section 5.4) suggest that eight out of the ten models
(i.e., except SVM and DPCNN) achieved significant performance improvements through these steps.
Although, none of the models showed significant degradation through these steps, significant gains were
dependent on algorithm selection, with CLE algorithms gaining only from keyword removal and identifier
splitting improving only the DNN ones.
Lesson 4: Performance boosts from the optional preprocessing steps are algorithm dependent.
The three optional preprocessing steps also improved performances of the classifiers. However, per-
formance gains through the these steps were algorithm dependent. The profane-count preprocessing
had the highest influence as nine out of the ten models gained performance with this step. On the other
id-split was the least useful one with only three DNN models gaining minor gains with this step. CLE
algorithms gained the most with ≈1% boost in terms of accuracies and 1 -3% in terms of 𝐹11scores. On
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.Automated Identification of Toxic Code Reviews Using ToxiCR •1:27
the other hand, DNN algorithms had relatively minor gains (i.e., less than 1%) in both accuracies and
𝐹11scores. Since DNN models utilize embedding vectors to identify semantic representation of texts,
those are less dependent on these optional preprocessing steps.
Lesson 5: Accurate identification of self-deprecating texts remains a challenge.
Almost 11% (out of 856 misclassified texts) of the errors from our best performing model were
due to self-deprecating texts. Challenges in identifying such texts have been also acknowledged by
prior toxicity detectors [ 41,88,93]. Due to the abundance of self-deprecating texts among code review
interactions [ 59,77], we believe that this can be an area to improve on for future SE domain specific
toxicity detectors.
Lesson 6: Achieving even higher performance is feasible. Since 85% of errors are due to failures of
our models to accurately comprehend the contexts of words, we believe achieving further improved
performance is feasible. Since supervised models learn better from larger training datasets, a larger
dataset (e.g., Jigsaw dataset includes 160K samples), may enable even higher performances. Second, NLP
is a rapidly progressing area with state-of-the-art techniques changing almost every year. Although, we
have not evaluated the most recent generation of models, such as GPT-3 [ 19] and XLNet [ 90] in this
study, those may help achieving better performances, as they are better at identifying contexts.
7 THREATS TO VALIDITY
In the following, we discuss the four common types of threats to validity for this study.
7.1 Internal validity
The first threat to validity for this study is our selection of data sources which come from four FOSS
projects. While these projects represent four different domains, many domains are not represented in
our dataset. Moreover, our projects represent some of the top FOSS projects with organized governance.
Therefore, several categories of highly offensive texts may be underrepresented in our datasets.
The notion of toxicity also depends on multitude of different factors such as culture, ethnicity, country
of origin, language, and relationship between the participants. We did not account for any such factors
during our dataset labeling.
7.2 Construct validity
Our stratified sampling strategy was based on toxicity scores obtained from the perspective API. Although,
we manually verified all the texts classified as ‘toxic’ by the PPA, we randomly selected only (5,5107
+ 9,000 =14,510) texts that had PPA scores of less than 0.5. Among those 14,510 texts, we identified
only 638 toxic ones (4.4%). If both the PPA and our random selections missed some categories of toxic
comments, instances of such texts may be missing in our datasets. Since our dataset is relatively large
(i.e., 19,651 ), we believe that this threat is negligible.
According to our definition, Toxicity is a large umbrella that includes various anti-social behaviour such
as offensive names, profanity, insults, threats, personal attacks, flirtations, and sexual references. Though
our rubric is based on the Conversational AI team, we have modified it to fit a diverse and multicultural
professional workplace such as an OSS project. As the notion of toxicity is a context dependent complex
phenomena, our definition may not fit many organizations, especially the homogeneous ones.
Researcher bias during our manual labeling process could also cause mislabeled instances. To eliminate
such biases, we focused on developing a rubric first. With the agreed upon rubric, two of the authors
7Code review 1 dataset
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.1:28•Sarker, et al.
independently labeled each text and achieved ‘almost perfect’ ( 𝜅=0.92) inter-rater agreement. Therefore,
we do not anticipate any significant threat arising from our manual labeling.
We did not change most of the hyperparameters for the CLE algorithms and accepted the default
parameters. Therefore, some of the CLE models may have achieved better performances on our datasets
through parameter tuning. To address this threat, we used the GridSearchCV function from the scikit-
learn library with the top two CLE models (i.e., RandomForest andDecisionTree ) to identify the best
parameter combinations. Our implementation explored six parameters with total 5,040 combinations for
RandomForest and five parameters with 360 combinations for DecisionTree. Our results suggest that
most of the default values are identical to those from the best performing combinations identified through
GridSearchCV . We also reevaluated RF and DT with the GridSearchCV suggested values, but did not
find any statistically significant (paired sample t-tests, 𝑝 >0.05) improvements over our already trained
models.
For the DNN algorithms, we did not conduct extensive hyperparameter search due to computational
costs. However, parameter values were selected based on the best practice reported in the deep learning
literature. Moreover, to identify the best DNN models we used validation sets and used EarlyStopping .
Still we may not have been able to achieve the best possible performances from the DNN models during
our evaluations.
7.3 External validity
Although, we have not used any project or code review specific pre-processing, our dataset may not
adequately represent texts from other projects or other software development interactions such as issue
discussions, commit messages, or question /answers on StackExchange. Therefore, our pretrained models
may have degraded performances on other contexts. However, our models can be easily retrained using a
different labeled datasets from other projects or other types of interactions. To facilitate such retraining,
we have made both the source code and instructions to retrain the models publicly available [76].
7.4 Conclusion validity
To evaluate the performances our models, we have standard metrics such as accuracy, precision, recall,
and F-scores. For the algorithm implementations, we have extensively used state-of-the-art libraries such
as scikit-learn [ 67] and TensorFlow [ 3]. We also used 10-fold cross-validations to evaluate the performances
of each model. Therefore, we do not anticipate any threats to validity arising from the set of metrics,
supporting library selection, and evaluation of the algorithms.
8 CONCLUSION AND FUTURE DIRECTIONS
This paper presents design and evaluation of ToxiCR, a supervised learning-based classifier to identify
toxic code review comments. ToxiCR includes a choice to select one of the ten supervised learning
algorithms, an option to select text vectorization techniques, five mandatory and three optional processing
steps, and a large-scale labeled dataset of 19,651 code review comments. With our rigorous evaluation
of the models with various combinations of preprocessing steps and vectorization techniques, we have
identified the best combination that boosts 95.8% accuracy and 88.9% 𝐹11score. We have released our
dataset, pretrained models, and source code publicly available on Github [ 76]. We anticipate this tool
being helpful in combating toxicity among FOSS communities. As a future direction, we aim to conduct
empirical studies to investigate how toxic interactions impact code review processes and their outcomes
among various FOSS projects.
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.Automated Identification of Toxic Code Reviews Using ToxiCR •1:29
REFERENCES
[1]2018. Annotation instructions for Toxicity with sub-attributes. https://github.com/conversationai/conversationai.
github.io/blob/main/crowdsourcing_annotation_schemes/toxicity_with_subattributes.md
[2]2018. Toxic Comment Classification Challenge. https://www.kaggle.com/c/jigsaw-toxic-comment-classification-
challenge
[3]Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay
Ghemawat, Geoffrey Irving, Michael Isard, Manjunath Kudlur, Josh Levenberg, Rajat Monga, Sherry Moore, Derek G.
Murray, Benoit Steiner, Paul Tucker, Vijay Vasudevan, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng.
2016. TensorFlow: A System for Large-Scale Machine Learning. In 12th USENIX Symposium on Operating Systems
Design and Implementation (OSDI 16) . USENIX Association, Savannah, GA, 265–283.
[4]Ashutosh Adhikari, Achyudh Ram, Raphael Tang, and Jimmy Lin. 2019. Docbert: Bert for document classification.
arXiv preprint arXiv:1904.08398 (2019).
[5]Sonam Adinolf and Selen Turkay. 2018. Toxic behaviors in Esports games: player perceptions and coping strategies. In
Proceedings of the 2018 Annual Symposium on Computer-Human Interaction in Play Companion Extended Abstracts .
365–372.
[6]Toufique Ahmed, Amiangshu Bosu, Anindya Iqbal, and Shahram Rahimi. 2017. SentiCR: a customized sentiment
analysis tool for code review interactions. In 2017 32nd IEEE/ACM International Conference on Automated Software
Engineering (ASE) . IEEE, 106–111.
[7]Conversation AI. [n.d.]. What if technology could help improve conversations online? https://www.perspectiveapi.com/
[8]Conversation AI. 2018. Annotation instructions for Toxicity with sub-attributes.
https://github.com/conversationai/conversationai.github.io/blob/master /crowdsourc-
ing_annotation_schemes/toxicity_with_subattributes.md.
[9]Basemah Alshemali and Jugal Kalita. 2020. Improving the reliability of deep neural networks in NLP: A review.
Knowledge-Based Systems 191 (2020), 105210.
[10]Ashley A Anderson, Sara K Yeo, Dominique Brossard, Dietram A Scheufele, and Michael A Xenos. 2018. Toxic talk:
How online incivility can undermine perceptions of media. International Journal of Public Opinion Research 30, 1
(2018), 156–168.
[11]Anonymous. 2014. Leaving Toxic Open Source Communities. https://modelviewculture.com/pieces/leaving-toxic-
open-source-communities
[12] Hayden Barnes. 2020. Toxicity in Open Source. https://boxofcables.dev/toxicity-in-linux-and-open-source/
[13]Joseph Berkson. 1944. Application of the logistic function to bio-assay. Journal of the American statistical association
39, 227 (1944), 357–365.
[14]Meghana Moorthy Bhat, Saghar Hosseini, Ahmed Hassan, Paul Bennett, and Weisheng Li. 2021. Say ‘YES’to Positivity:
Detecting Toxic Language in Workplace Communications. In Findings of the Association for Computational Linguistics:
EMNLP 2021 . 2017–2029.
[15]Piotr Bojanowski, Edouard Grave, Armand Joulin, and Tomas Mikolov. 2017. Enriching word vectors with subword
information. Transactions of the Association for Computational Linguistics 5 (2017), 135–146.
[16] Amiangshu Bosu and Jeffrey C Carver. 2013. Impact of peer code review on peer impression formation: A survey. In
2013 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement . IEEE, 133–142.
[17]Amiangshu Bosu, Anindya Iqbal, Rifat Shahriyar, and Partha Chakroborty. 2019. Understanding the Motivations,
Challenges and Needs of Blockchain Software Developers: A Survey. Empirical Software Engineering 24, 4 (2019),
2636–2673.
[18] Leo Breiman. 1996. Bagging predictors. Machine learning 24, 2 (1996), 123–140.
[19]Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan,
Pranav Shyam, Girish Sastry, Amanda Askell, et al .2020. Language models are few-shot learners. Advances in neural
information processing systems 33 (2020), 1877–1901.
[20]Fabio Calefato, Filippo Lanubile, and Nicole Novielli. 2017. EmoTxt: a toolkit for emotion recognition from text. In
2017 seventh international conference on Affective Computing and Intelligent Interaction Workshops and Demos
(ACIIW) . IEEE, 79–80.
[21]Kevin Daniel André Carillo, Josianne Marsan, and Bogdan Negoita. 2016. Towards Developing a Theory of Toxicity in
the Context of Free/Open Source Software & Peer Production Communities. SIGOPEN 2016 (2016).
[22]Hao Chen, Susan McKeever, and Sarah Jane Delany. 2019. The Use of Deep Learning Distributed Representations in
the Identification of Abusive Text. In Proceedings of the International AAAI Conference on Web and Social Media ,
Vol. 13. 125–133.
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.1:30•Sarker, et al.
[23]Savelie Cornegruta, Robert Bakewell, Samuel Withey, and Giovanni Montana. 2016. Modelling Radiological Language
with Bidirectional Long Short-Term Memory Networks. EMNLP 2016 (2016), 17.
[24] Corinna Cortes and Vladimir Vapnik. 1995. Support-vector networks. Machine learning 20, 3 (1995), 273–297.
[25]Cristian Danescu-Niculescu-Mizil, Moritz Sudhof, Dan Jurafsky, Jure Leskovec, and Christopher Potts. 2013. A
Computational Approach to Politeness with Application to Social Factors. In 51st Annual Meeting of the Association
for Computational Linguistics . ACL, 250–259.
[26]R Van Wendel De Joode. 2004. Managing conflicts in open source communities. Electronic Markets 14, 2 (2004),
104–113.
[27]Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of Deep Bidirectional
Transformers for Language Understanding. (June 2019), 4171–4186. https://doi.org/10.18653/v1/N19-1423
[28] Maeve Duggan. 2017. Online harassment 2017. (2017).
[29]Carolyn D Egelman, Emerson Murphy-Hill, Elizabeth Kammer, Margaret Morrow Hodges, Collin Green, Ciera Jaspan,
and James Lin. 2020. Predicting developers’ negative feelings about code review. In 2020 IEEE/ACM 42nd International
Conference on Software Engineering (ICSE) . IEEE, 174–185.
[30]Ahmed Elnaggar, Bernhard Waltl, Ingo Glaser, Jörg Landthaler, Elena Scepankova, and Florian Matthes. 2018. Stop
Illegal Comments: A Multi-Task Deep Learning Approach. In Proceedings of the 2018 Artificial Intelligence and Cloud
Computing Conference . 41–47.
[31]Nelly Elsayed, Anthony S Maida, and Magdy Bayoumi. 2019. Deep Gated Recurrent and Convolutional Network
Hybrid Model for Univariate Time Series Classification. International Journal of Advanced Computer Science and
Applications 10, 5 (2019).
[32] Samir Faci. 2020. The Toxicity Of Open Source. https://www.esamir.com/20/12/23/the-toxicity-of-open-source/
[33]Isabella Ferreira, Jinghui Cheng, and Bram Adams. 2021. The" Shut the f** k up" Phenomenon: Characterizing
Incivility in Open Source Code Review Discussions. Proceedings of the ACM on Human-Computer Interaction 5,
CSCW2 (2021), 1–35.
[34]Anna Filippova and Hichang Cho. 2016. The effects and antecedents of conflict in free and open source software
development. In Proceedings of the 19th ACM Conference on Computer-Supported Cooperative Work & Social
Computing . 705–716.
[35]LibreOffice: The Document Foundation. [n.d.]. Code of Conduct. https://www.documentfoundation.org/foundation/
code-of-conduct/.
[36]Jerome H Friedman. 2001. Greedy function approximation: a gradient boosting machine. Annals of statistics (2001),
1189–1232.
[37]Spiros V Georgakopoulos, Sotiris K Tasoulis, Aristidis G Vrahatis, and Vassilis P Plagianakos. 2018. Convolutional
neural networks for toxic comment classification. In Proceedings of the 10th Hellenic Conference on Artificial Intelligence .
1–6.
[38]Alex Graves and Jürgen Schmidhuber. 2005. Framewise phoneme classification with bidirectional LSTM and other
neural network architectures. Neural networks 18, 5-6 (2005), 602–610.
[39]Isuru Gunasekara and Isar Nejadgholi. 2018. A review of standard text classification practices for multi-label toxicity
identification of online content. In Proceedings of the 2nd workshop on abusive language online (ALW2) . 21–25.
[40] Sanuri Dananja Gunawardena, Peter Devine, Isabelle Beaumont, Lola Garden, Emerson Rex Murphy-Hill, and Kelly
Blincoe. 2022. Destructive Criticism in Software Code Review Impacts Inclusion. (2022).
[41] Laura Hanu and Unitary team. 2020. Detoxify. Github. https://github.com/unitaryai/detoxify.
[42]Tin Kam Ho. 1995. Random decision forests. In Proceedings of 3rd international conference on document analysis and
recognition , Vol. 1. IEEE, 278–282.
[43]Sepp Hochreiter and Jürgen Schmidhuber. 1997. Long short-term memory. Neural computation 9, 8 (1997), 1735–1780.
[44]Hossein Hosseini, Sreeram Kannan, Baosen Zhang, and Radha Poovendran. 2017. Deceiving google’s perspective api
built for detecting toxic comments. arXiv preprint arXiv:1702.08138 (2017).
[45]Zhiheng Huang, Wei Xu, and Kai Yu. 2015. Bidirectional LSTM-CRF models for sequence tagging. arXiv preprint
arXiv:1508.01991 (2015).
[46]N. Imtiaz, J. Middleton, J. Chakraborty, N. Robson, G. Bai, and E. Murphy-Hill. 2019. Investigating the Effects
of Gender Bias on GitHub. In 2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE) .
700–711.
[47]Md Zahidul Islam, Jixue Liu, Jiuyong Li, Lin Liu, and Wei Kang. 2019. A semantics aware random forest for text
classification. In Proceedings of the 28th ACM international conference on information and knowledge management .
1061–1070.
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.Automated Identification of Toxic Code Reviews Using ToxiCR •1:31
[48]Carlos Jensen, Scott King, and Victor Kuechler. 2011. Joining free/open source software communities: An analysis of
newbies’ first interactions on project mailing lists. In 2011 44th Hawaii international conference on system sciences .
IEEE, 1–10.
[49]Rie Johnson and Tong Zhang. 2017. Deep pyramid convolutional neural networks for text categorization. In Proceedings
of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers) . 562–570.
[50]Robbert Jongeling, Proshanta Sarkar, Subhajit Datta, and Alexander Serebrenik. 2017. On negative results when using
sentiment analysis tools for software engineering research. Empirical Software Engineering 22, 5 (2017), 2543–2584.
[51]Diederik P. Kingma and Jimmy Ba. 2015. Adam: A Method for Stochastic Optimization. (2015). http://dblp.uni-
trier.de/db/conf/iclr/iclr2015.html#KingmaB14
[52]Kamran Kowsari, Donald E Brown, Mojtaba Heidarysafa, Kiana Jafari Meimandi, Matthew S Gerber, and Laura E
Barnes. 2017. Hdltex: Hierarchical deep learning for text classification. In 2017 16th IEEE international conference on
machine learning and applications (ICMLA) . IEEE, 364–371.
[53]Deepak Kumar, Patrick Gage Kelley, Sunny Consolvo, Joshua Mason, Elie Bursztein, Zakir Durumeric, Kurt Thomas,
and Michael Bailey. 2021. Designing toxic content classification for a diversity of perspectives. In Seventeenth Symposium
on Usable Privacy and Security (SOUPS 2021) . 299–318.
[54]Keita Kurita, Anna Belova, and Antonios Anastasopoulos. 2019. Towards Robust Toxic Content Classification. arXiv
preprint arXiv:1912.06872 (2019).
[55]Zijad Kurtanović and Walid Maalej. 2018. On user rationale in software engineering. Requirements Engineering 23, 3
(2018), 357–379.
[56]Bin Lin, Fiorella Zampetti, Gabriele Bavota, Massimiliano Di Penta, Michele Lanza, and Rocco Oliveto. 2018. Sentiment
analysis for software engineering: How far can we go?. In Proceedings of the 40th international conference on software
engineering . 94–104.
[57]Ilya Loshchilov and Frank Hutter. 2018. Decoupled Weight Decay Regularization. International Conference on Learning
Representations (2018).
[58]Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. 2013. Distributed representations of words
and phrases and their compositionality. In Advances in neural information processing systems . 3111–3119.
[59]Courtney Miller, Sophie Cohen, Daniel Klug, Bodgan Vasilescu, and Christian Kästner. 2022. “Did You Miss My
Comment or What?” Understanding Toxicity in Open Source Discussions. In International Conference on Software
Engineering, ICSE, ACM (2022) (ICSE) . IEEE, ACM.
[60]Pushkar Mishra, Helen Yannakoudakis, and Ekaterina Shutova. 2018. Neural Character-based Composition Models for
Abuse Detection. EMNLP 2018 (2018), 1.
[61]Murtuza Mukadam, Christian Bird, and Peter C Rigby. 2013. Gerrit software code review data from android. In 2013
10th Working Conference on Mining Software Repositories (MSR) . IEEE, 45–48.
[62]Dawn Nafus, James Leach, and Bernhard Krieger. 2006. Gender: Integrated report of findings. FLOSSPOLS, Deliverable
D16 (2006).
[63]Chikashi Nobata, Joel Tetreault, Achint Thomas, Yashar Mehdad, and Yi Chang. 2016. Abusive language detection in
online user content. In Proceedings of the 25th international conference on world wide web . 145–153.
[64]Nicole Novielli, Daniela Girardi, and Filippo Lanubile. 2018. A benchmark study on sentiment analysis for software
engineering research. In 2018 IEEE/ACM 15th International Conference on Mining Software Repositories (MSR) .
IEEE, 364–375.
[65] OpenStack. [n.d.]. OpenStack Code of Conduct. https://wiki.openstack.org/wiki/Conduct.
[66]Rajshakhar Paul, Amiangshu Bosu, and Kazi Zakia Sultana. 2019. Expressions of Sentiments during Code Reviews:
Male vs. Female. In Proceedings of the 26th IEEE International Conference on Software Analysis, Evolution and
Reengineering (Hangzhou, China) (SANER ‘19) . IEEE.
[67]Fabian Pedregosa, Gaël Varoquaux, Alexandre Gramfort, Vincent Michel, Bertrand Thirion, Olivier Grisel, Mathieu
Blondel, Peter Prettenhofer, Ron Weiss, Vincent Dubourg, et al .2011. Scikit-learn: Machine learning in Python. the
Journal of machine Learning research 12 (2011), 2825–2830.
[68]Jeffrey Pennington, Richard Socher, and Christopher D Manning. 2014. Glove: Global vectors for word representation.
InProceedings of the 2014 conference on empirical methods in natural language processing (EMNLP) . 1532–1543.
[69] Android Open Source Project. [n.d.]. Code of Conduct. https://source.android.com/setup/cofc.
[70]Huilian Sophie Qiu, Bogdan Vasilescu, Christian Kästner, Carolyn Denomme Egelman, Ciera Nicole Christopher
Jaspan, and Emerson Rex Murphy-Hill. 2022. Detecting Interpersonal Conflict in Issues and Code Review: Cross
Pollinating Open-and Closed-Source Approaches. (2022).
[71] J. Ross Quinlan. 1986. Induction of decision trees. Machine learning 1, 1 (1986), 81–106.
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.1:32•Sarker, et al.
[72]Israr Qureshi and Yulin Fang. 2011. Socialization in open source software projects: A growth mixture modeling
approach. Organizational Research Methods 14, 1 (2011), 208–238.
[73]Naveen Raman, Minxuan Cao, Yulia Tsvetkov, Christian Kästner, and Bogdan Vasilescu. 2020. Stress and Burnout in
Open Source: Toward Finding, Understanding, and Mitigating Unhealthy Interactions. In International Conference on
Software Engineering, New Ideas and Emerging Results (ICSE) . ACM, TBD.
[74]David E Rumelhart, Geoffrey E Hinton, and Ronald J Williams. 1986. Learning representations by back-propagating
errors.nature323, 6088 (1986), 533–536.
[75]Maarten Sap, Dallas Card, Saadia Gabriel, Yejin Choi, and Noah A Smith. 2019. The risk of racial bias in hate speech
detection. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics . 1668–1678.
[76]Jaydeb Sarkar, Asif Turzo, Ming Dong, and Amiangshu Bosu. 2022. ToxiCR: Replication package. Github.
https://github.com/WSU-SEAL/ToxiCR.
[77]Jaydeb Sarker, Asif Kamal Turzo, and Amiangshu Bosu. 2020. A benchmark study of the contemporary toxicity
detectors on software engineering interactions. In 2020 27th Asia-Pacific Software Engineering Conference (APSEC)
(Singapore). 218–227. https://doi.org/10.1109/APSEC51365.2020.00030
[78]Jaydeb Sarker, Asif Kamal Turzo, Ming Dong, and Amiangshu Bosu. 2022. WSU SEAL implementation of the
STRUDEL Toxicity detector. https://github.com/WSU-SEAL/toxicity-detector/tree/master/WSU_SEAL.
[79]Carl-Erik Särndal, Bengt Swensson, and Jan Wretman. 2003. Model assisted survey sampling . Springer Science &
Business Media.
[80]Robert E Schapire. 2003. The boosting approach to machine learning: An overview. Nonlinear estimation and
classification (2003), 149–171.
[81]Megan Squire and Rebecca Gazda. 2015. FLOSS as a Source for Profanity and Insults: Collecting the Data. In 2015
48th Hawaii International Conference on System Sciences . IEEE, 5290–5298.
[82]Saurabh Srivastava, Prerna Khurana, and Vartika Tewari. 2018. Identifying aggression and toxicity in comments
using capsule network. In Proceedings of the First Workshop on Trolling, Aggression and Cyberbullying (TRAC-2018) .
98–105.
[83]Igor Steinmacher and Marco Aurélio Gerosa. 2014. How to support newcomers onboarding to open source software
projects. In IFIP International Conference on Open Source Systems . Springer, 199–201.
[84]Pannavat Terdchanakul, Hideaki Hata, Passakorn Phannachitta, and Kenichi Matsumoto. 2017. Bug or not? bug
report classification using n-gram idf. In 2017 IEEE international conference on software maintenance and evolution
(ICSME) . IEEE, 534–538.
[85]Ameya Vaidya, Feng Mai, and Yue Ning. 2020. Empirical analysis of multi-task learning for reducing identity bias in
toxic comment detection. Proceedings of the International AAAI Conference on Web and Social Media 14 (2020),
683–693.
[86]Betty van Aken, Julian Risch, Ralf Krestel, and Alexander Löser. 2018. Challenges for Toxic Comment Classification:
An In-Depth Error Analysis. Proceedings of the 2nd Workshop on Abusive Language Online (ALW2) (2018), 33–42.
[87]Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia
Polosukhin. 2017. Attention is all you need. Advances in neural information processing systems 30 (2017).
[88]Susan Wang and Zita Marinho. 2020. Nova-Wang at SemEval-2020 Task 12: OffensEmblert: An Ensemble ofOffensive
Language Classifiers. In Proceedings of the Fourteenth Workshop on Semantic Evaluation . 1587–1597.
[89]Mengzhou Xia, Anjalie Field, and Yulia Tsvetkov. 2020. Demoting Racial Bias in Hate Speech Detection. Proceedings
of the Eighth International Workshop on Natural Language Processing for Social Media (2020), 7–14.
[90]Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Russ R Salakhutdinov, and Quoc V Le. 2019. Xlnet:
Generalized autoregressive pretraining for language understanding. Advances in neural information processing systems
32 (2019).
[91]Sara Zaheri, Jeff Leath, and David Stroud. 2020. Toxic Comment Classification. SMU Data Science Review 3, 1 (2020),
13.
[92]Marcos Zampieri, Preslav Nakov, Sara Rosenthal, Pepa Atanasova, Georgi Karadzhov, Hamdy Mubarak, Leon Derczyn-
ski, Zeses Pitenis, and Çağrı Çöltekin. 2020. SemEval-2020 Task 12: Multilingual Offensive Language Identification in
Social Media (OffensEval 2020). In Proceedings of the Fourteenth Workshop on Semantic Evaluation . 1425–1447.
[93]Justine Zhang, Jonathan P Chang, Cristian Danescu-Niculescu-Mizil, Lucas Dixon, Yiqing Hua, Nithum Tahin, and
Dario Taraborelli. 2018. Conversations Gone Awry: Detecting Early Signs of Conversational Failure.. In Proceedings of
the 56th Annual Meeting of the Association for Computational Linguistics. , Vol. 1.
[94]Xiang Zhang, Junbo Zhao, and Yann LeCun. 2015. Character-level convolutional networks for text classification.
Advances in neural information processing systems 28 (2015), 649–657.
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.Automated Identification of Toxic Code Reviews Using ToxiCR •1:33
[95]Yukun Zhu, Ryan Kiros, Rich Zemel, Ruslan Salakhutdinov, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. 2015.
Aligning Books and Movies: Towards Story-Like Visual Explanations by Watching Movies and Reading Books. In The
IEEE International Conference on Computer Vision (ICCV) .
ACM Trans. Softw. Eng. Methodol., Vol. 32, No. 1, Article 1. Publication date: January 2023.