On Using Active Learning and Self-Training when Mining Performance Discussions on Stack Overflow

TL;DR

This paper explores the combined use of active learning and self-training to improve classification of Stack Overflow posts, highlighting challenges in annotation and demonstrating potential accuracy gains.

Contribution

It systematically evaluates active learning and self-training for classifying technical discussions, revealing annotation difficulties and proposing mitigation strategies.

Findings

Active learning identifies valuable but difficult-to-annotate examples.

Self-training can enhance classifier accuracy with limited labeled data.

Low inter-rater agreement highlights annotation challenges.

Abstract

Abundant data is the key to successful machine learning. However, supervised learning requires annotated data that are often hard to obtain. In a classification task with limited resources, Active Learning (AL) promises to guide annotators to examples that bring the most value for a classifier. AL can be successfully combined with self-training, i.e., extending a training set with the unlabelled examples for which a classifier is the most certain. We report our experiences on using AL in a systematic manner to train an SVM classifier for Stack Overflow posts discussing performance of software components. We show that the training examples deemed as the most valuable to the classifier are also the most difficult for humans to annotate. Despite carefully evolved annotation criteria, we report low inter-rater agreement, but we also propose mitigation strategies. Finally, based on one annotator's work, we show that self-training can improve the classification accuracy. We conclude the paper by discussing implication for future text miners aspiring to use AL and self-training.

Tables

Table 1. TABLE I: Results from self-training as a complement to B’s training set. Baseline shows the results from iteration 16, other rows show differences in absolute values.

Approach	Accuracy	Precision	Recall	$F_1$-score
Baseline	0.700	0.574	0.344	0.428
1) +5% pos.	+0.019	+0.024	+0.096	+0.080
2) +50% neg.	+0.025	+0.069	+0.037	+0.046
1) and 2)	+0.043	+0.103	+0.067	+0.079

Full text

I Introduction

Large datasets are key to successful machine learning and text mining. For example, applying natural language related machine learning to text at web scale [1] has enabled many of the advances in the last decade. It is well known that an algorithm that works well on small datasets might be beaten by simpler alternatives as more data are used for training [2]. However, while the web contains huge amounts of text, supervised learning requires annotated data – data that are hard to obtain.

A common solution to acquire enough annotated data is crowdsourcing using services such as Amazon Mechanical Turk. The possibility to employ a massive, distributed, anonymous crowd of individuals to perform general human-intelligence micro-tasks for micro-payments has radically changed the way many researchers work [3]. However, when annotation requires more than general human intelligence, i.e., for non-trivial micro-tasks, such crowdsourcing solutions might not work. Annotation of developers’ posts on Stack Overflow is an example of non-trivial classification for which successful crowdsourcing cannot be expected.

Active Learning (AL) is a semi-automated approach to establish a training set. The idea is to reduce the overall human effort by focusing on annotating examples that maximize the gained learning, i.e., the examples for which the classifier is the most uncertain. AL has been used for software fault prediction, successfully reducing the need for human intervention [4, 5, 6]. AL has also been used in several other fields of research, e.g., for creating large training sets for speech recognition and information extraction [7]. Several studies show that AL can successfully be combined with self-training, which is a method to extend the training set by automatic labeling of a trained classifier [8, 9, 10], but the techniques have not previously been used for text mining Stack Overflow.

In this study, our target training set is Stack Overflow discussions on performance of software components. Our work is part of the ORION project, in which we aim at developing a decision-support system for software component selection [11]. One aspect under study is how to collect and store experiences from previous decisions [12]. The ORION project proposes collecting experiences from both internal and external sources, i.e., both from the company and from other organizations. In this paper, we address using machine learning to extract external experiences from the software engineering community by text mining Stack Overflow, the leading technical Q&A platform for software developers [13].

We report our experiences from using AL and an SVM classifier in a systematic way consisting of 16 iterations. Our findings show that not only the classifier is uncertain regarding the borderline cases – also the human annotators display limited agreement. Consequently, we stress that annotation criteria must continuously evolve during AL. Moreover, we suggest that AL with multiple annotators should be designed with partly overlapping iterations to enable detection of different interpretations. Finally, we demonstrate that self-training has the potential to improve classification accuracy.

The rest of the paper is organized as follows: Section II introduces background and related work, Section III presents the design of our study, and Section IV discusses our findings. Finally, we summarize our implications for future mining operations in Section V.

II Background and Related Work

Stack Overflow is the dominant technical Q&A platform for software developers, with 101 million monthly unique visitors (March 2017). The information available on Stack Overflow has been studied extensively in the software engineering community, mostly through text mining, but also through qualitative analysis. Fig. 1 shows an example of a Stack Overflow question with an answer, in which we highlight text chunks related to performance.

Treude et al. investigated the type of questions asked and the quality of the answers and found that the information is particularly useful for code reviews and conceptual questions, and for novice developers  [14]. Soliman et al. found that Stack Overflow contains information relevant to and useful for decisions within software architectural design, and have idenitified a list of words that may be used to automatically classify such information  [15]. Topic modelling has been used to identify what topics that are discussed and relationships between these. In this way, Barua et al. identify a number of current trends within software development, e.g., that mobile app development is increasing faster than web development  [13]. It is suggested that knowledge mined from Stack Overflow can be used to provide context-relevant hints in IDEs  [16, 17] and for filtering out off-topic posts, e.g., in chat channels  [18].

AL is a semi-supervised machine learning approach in which a learning algorithm interactively queries the human to obtain labels for specific examples, typically the most difficult ones. The method for selecting examples to query should be optimized to maximize the gained learning. Uncertainty sampling is a simple technique that selects examples where the classifier is least certain on which label to apply [7]. This has the effect of separating the examples into two distinct groups and thus remove borderline cases, see the horizontal histograms in Fig. 2. AL enables a shift of focus from momentary data analysis to a process with a feedback loop [19, 20].

When mining from crowdsourced data there are usually too many unlabelled examples to annotate them all manually. Semi-supervised learning are methods that use also remaining unlabelled examples to improve the classifier. Self-training (or bootstrap learning [21]) is one such method that extends the training set with the unlabelled examples classified with the highest degree of certainty. This complements AL with uncertainty sampling well, since it maximizes the available confident labels [7]. To the best of our knowledge, we present the first application of both AL and self-training for Stack Overflow mining.

III Method

We designed a study to evaluate AL when mining Stack Overflow. Fig. 3 shows an overview of the research design that consisted of a preparation step and two iterative training steps. In the preparation step, we downloaded the dataset used for the MSR Mining Challenge in 2015 containing 43,336,603 posts [22]. We extracted all that were tagged with ‘performance’ and at least one of the following tags: ‘apache’, ‘nginx’ or ‘rails’ – an attempt to get an initial dataset related to components we know well, resulting in 2,304 posts in total.

Preparation To assist the manual annotation task, we developed a prototype tool integrating an SVM classifier from scikit-learn [23], i.e., the classifier finds the optimal hyperplane separating two categories of examples [24]. In our application, we trained an SVM classifier with n-grams as features (n=1-5) to separate Stack Overflow posts related to performance discussions of software components and other posts. We refer to the two categories as positive and negative examples, respectively.

During the tool development, the first and second authors alternated annotating posts and evolving initial annotation criteria – note that this inital step was done without AL. In total, we annotated 970 posts (25.4% positive) and the criteria evolved into “a positive post discusses the performance of a software component, rather than programming languages, the development environment, or measurements tools”. While manually annotating the initially posts, we identified 67 additional component names that also had explicit Stack Overflow tags. We used this to extend our dataset, i.e., we complemented ‘apache’, ‘nginx’ or ‘rails’ with 67 new tags to obtain a larger dataset of Stack Overflow posts. In total we collected 15,287 Stack Overflow posts potentially related to performance of software components111Replication package: URL.

Active learning After the preparation, the first and second authors alternated manual annotation of the next 100 posts222A reasonable annotation task that requires roughly 90 min. closest to the SVM hyperplane – we refer to each such annotation batch [25] as an AL iteration. For each iteration, we measured the classification accuracy complemented by precision, recall, and $F_{1}$-score using 5-fold cross-validation. Furthermore, we calculated the distance from each post, both labelled and unlabelled, to the SVM hyperplane. We visualize the distribution of posts at different distances from the SVM hyperplane using histograms and beanplots.

Self-training We investigated self-training based on the second author’s annotation activity (cf. ‘Self-train. in Fig. 3) by adding unlabelled examples as if they were manually annotated. We explored extending the training set with different percentages of unlabelled data, corresponding to different distances to the SVM hyperplane. Our ambition was to identify a successful application of self-training, useful as a proof-of-concept, rather than finding the optimal parameter settings for this particular case.

Human annotation To measure the uncertainty in classifying Stack Overflow posts close to the SVM hyperplane, we evaluated the inter-rater reliability of human annotators. The first and second author discussed experiences after each completed iteration, and the annotation criteria evolved. After 8 iterations, halfway into the study, we considered the criteria mature enough for evaluation. The criteria were then:

“A positive post (both questions and answers) addresses the performance of a specific software component (incl. frameworks, platforms, and libraries) that could be used to evolve a software-intensive system. Examples: database management systems (MySQL, Oracle, ..), content management systems (Drupal, Joomla, ..), web servers.

A post is negative if it discusses performance of/from:

• •

programming languages (e.g., Java, PHP)

• •

operational environments (e.g., Windows, Linux)

• •

development tools (e.g., compilers, IDEs, build systems.)

• •

alternative detailed implementations (e.g., formulation of SQL queries, parsing of XML/JSON structures)

• •

tweaking of components

or if the post discusses components used to measure performance (e.g., JMeter, SQLTest). The exclusion criteria apply, unless such a discussion clearly originates in poor performance of a specific component”.

We designed a hands-on annotation exercise during a research workshop with 12 senior software engineering researchers (cf. ‘Group annotation’ in Fig. 3). First, we introduced the exercise, showed some examples, and provided the above criteria. Second, everyone independently annotated 11 posts, printed on paper, during a 20 minute session. In total, 66 posts were distributed using pairwise assignment: two annotators per post, and each possible human pair represented once. Finally, we calculated Krippendorff’s $\alpha$ to assess inter-rater reliability, as recommended for difficult nominal tasks [26].

After the group annotation, we discussed the outcome to better understand our differences. We continued the annotation activity, following the same process and expecting a growing shared understanding, until iteration 16. Once finished, we had 2,567 annotated posts (32.6% positive). To check our hypothesis of improving agreement, we randomly selected 50 posts among the already annotated (cf. ‘Pair annotation’ in Fig. 3). Again we calculated Krippendorff’s $\alpha$, both 1) between the first and second authors (referred to as A and B), and 2) between the new labels and the previous labels. For each post annotated differently, we quantified the certainty of the set label (1-5) and we provided a rationale.

IV Results and Lessons Learned

Human annotation We begin this section by reporting on the inter-rater reliability. The results from our group annotation exercise after 8 iterations confirmed the challenge of annotating posts close to the SVM hyperplane. Despite annotation criteria that evolved during 8 AL-iterations, the 12 annotators obtained a Krippendorff’s $\alpha$ of 0.126 (37/66 shared labels, 56%) – a poor agreement. The first and second authors analyzed the discrepancies, along with posts for which there were agreement, without identifying any concrete patterns. The presence of borderline cases is obvious, but we hypothesized that the alignment between the first and second authors was stronger than within the whole group, and that it would continue improving during the remaining iterations.

After 16 AL-iterations, we calculated the inter-rater reliability between A and B for a random sample of 50 previously annotated posts. The exercise yielded a Krippendorff’s $\alpha$ of 0.028 (29/50 shared labels, 58%), considerably lower than from the group exercise. We also calculated the inter-rater reliability against our previous annotations of the 50 posts, obtaining a Krippendorff’s $\alpha$ of 0.768 (18/20 shared labels, 90%), and 0.577 (24/30 shared labels, 80%) for A and B, respectively. Our results show that while our individual annotation remained stable over time, our shared view still differed after 16 iterations.

In most cases at least one of us was very uncertain, expressing a certainty level of 1 or 2, which means the post was more or less randomly labelled. More alarming, however, was that in several cases both annotators felt certain but used different labels. An analysis of the latter cases revealed that A was more inclusive regarding posts that related to implementation details and component tweaking, whereas B was more inclusive concerning quality attributes not necessarily related to performance. Furthermore, B did not include posts that could be interpreted as anecdotal experiences. We conclude that AL for text classification is difficult, even after annotating 2,674 posts with several intermediate discussions, our inter-rater reliability was low.

Active learning Since our annotation criteria did not properly align our annotation activity, we hesitated to pool our training data. Instead, we trained three separate SVM classifiers using: 1) A data, 2) B data, and 3) A+B data – we refer to these as SVM A, SVM B, and SVM A+B, respectively. Note that we also split the training data from iteration 0 into either A or B, resulting in differently large initial training sets.

Fig. 4 shows the mean value from five runs of 5-fold cross-validation for each iteration. The solid lines with markers show accuracy and $F_{1}$-score for SVM A, the dashed lines with markers represent SVM B, and the solid lines without markers illustrate SVM A+B. Regarding accuracy, all three classifiers show similar behavior: The accuracy decreases as additional iterations are added, but the differences are minor. The curves do not resemble typical learning curves, instead they appear to stabilize between 0.7 and 0.8. We explain this by the posts annotated for iteration 0, i.e., clearly positive and negative examples were selected to span the document space, followed by nothing but borderline cases selected using AL. Looking at $F_{1}$-score, SVM B and SVM A+B remain fairly stable around 0.5. On the other hand, SVM A improves considerably as more iterations are added. This is likely due to the distribution of examples in the small A iteration 0 training set, containing only 373 examples and a recall of only 0.18 – even adding borderline cases was useful in this case.

Fig. 5 depicts distances between annotated posts and the SVM hyperplanes (SVM A and SVM B) after the preparation step and after the final iterations. The vertical histograms show frequency distributions of posts with distances from the hyperplane on the y-axis, where the sign denotes positive and negative classifications, respectively. Moreover, the figure displays the number of true positives (TP), false positives (FP), true negatives (TN), and false negatives (FN). We notice that as more posts are annotated, the distribution around the hyperplane increases, which is particularly evident for the true negatives. This shows that, from the perspective of the SVM classifiers, 16 AL iterations did not reduce the number of borderline posts.

Fig. 6 presents an analogous view for the unlabelled posts, also separating SVM A and SVM B. However, in this figure we show beanplots, i.e., the frequencies are mirrored on the y-axis. We also report the number of unlabelled posts on both sides of the hyperplanes (cf. $|p|$). SVM A suggests that there are 716 positive posts remaining in the set of set 13,745 posts, whereas SVM B gives 259 remaining positive posts – these figures reflect A’s more inclusive interpretation of the annotation criteria. The goal of AL is to focus annotation efforts on borderline cases to create two clearly separated clusters of examples (cf. Fig. 2). This phenomenon is not obvious in the Fig. 6, although we observe that SVM B indeed has fewer negative examples close to the hyperplane, i.e., the beanplot close to 0 is thinner after iteration 16. The pattern for SVM A is less clear, and we aim at investigating this in future work by conducting additional iterations.

Self-training The rightmost part of Fig. 6 also illustrates how we evaluated self-training using data annotated by B. As depicted by the dashed horizontal line, we explored adding different fractions of the most confidently classified examples (cf. the white bars) to the training set, annotated with the label predicted by the classifier. As a proof-of-concept, we report our results from adding the following unlabelled examples: 1) 5% positive examples, 2) 50% negative examples, and 3) 5% positive examples, and 50% negative examples. These additions represent adding unlabelled examples farther away from the hyperplane than 1.76 on the positive side, and 0.88 on the negative side.

Table I shows our results, compared to the baseline provided by iteration 16 without any self-training. Our results show that active learning combined with self-training can be used to improve an SVM classifier for Stack Overflow posts. Both adding positive and negative examples from the unlabelled examples can improve classification accuracy. We obtained the best results when adding both types of data, resulting in improvements from the baseline corresponding to +4.3% accuracy, +10.3% precision, +6.7% recall, and +7.9% $F_{1}$-score.

Limitations Finally, we briefly discuss two aspects of threats to validity. First, we stress that we have populated Table I by cherry-picking results from successful self-training runs. Most of our trial runs with self-training generated similar or worse results. Using an approach to semi-exhaustively evaluate different self-training settings, in total running about 50 experimental runs, Table I shows the best results we obtained. However, our work is not a case of publication bias as we aim only to exhibit the existence of a phenomenon [27] – a beneficial application of self-training when text mining software repositories. Most self-training settings might deteriorate the accuracy, and a more systematic approach to parameter tuning [28] would probably identify even better settings.

Second, the external validity [29] of our work is limited. AL might be better suited for other software engineering text annotation tasks with less human interpretation. It is probable that another set of annotators, guided by other annotation guidelines, would result in a different inter-rater reliability. As highlighted by Settles [25], while evolving annotation criteria is often a practical reality when applying AL, changes is a violation of the basic stability assumption. We also cannot claim that self-training is beneficial to all types of text mining tasks in software engineering. What we can say, however, is that for our particular task of classifying Stack Overflow posts related to performance of software components, self-training yielded improvements – and that is enough to recommend further research.

V Conclusion and Implications for Future Text Mining

We explored using AL and an SVM classifier for Stack Overflow posts with two alternating annotators. The primary lesson learned is that AL and text mining appears to be a difficult combination, at least for short texts such as Stack Overflow posts. In contrast to image classification tasks333Please refer to Karen Zack’s viral tweets, e.g., “chihuahua or muffin?”: http://ow.ly/zpF1308F7kK, human Stack Overflow annotators must interpret incomplete information presented with limited context – differences in annotations are inevitable. However, we argue that awareness of this intrinsic challenge of AL can be used to complement a traditional annotation process, i.e., AL can be used to identify the borderline cases that are worthwhile to discuss.

Based on our experiences, we present two recommendations when using AL for text mining software repositories. First, the annotation criteria must continuously evolve, in parallel to the annotators’ interpretation of them, in line with coding guidelines for qualitative research [29]. It is not enough to simply count the number of differing labels, instead qualitative analysis is needed to identify any potential systematic differences – before it is too late. Second, we suggest that AL settings with multiple annotators should be designed with partly overlapping iterations to enable early detection of discrepancies. The size of the labelled training set would increase at a slower rate with overlapping iterations, thus this must be balanced against the value of better annotator alignment. In future attempts with AL, we plan to initially design iterations with 25% overlap, and then gradually decrease it to 5% as consensus increases.

Based on the second author’s AL process, we evaluated complementing the training set using self-training. Our results are promising, we show that adding both positive and negative examples to the training set can increase the classification accuracy. In a semi-structured approach, we achieved improvements of 4.3% accuracy and 7.9% $F_{1}$-score. We stress that our findings do not suggest that self-training generally is a good idea, rather our results constitute a proof-of-concept that self-training can be successfully combined with AL. Furthermore, we expect that further improvements from self-training would be possible, and plan to conduct systematic parameter optimization as the next step [28].

Acknowledgment

The work is partially supported by a research grant for the ORION project (reference number 20140218) from The Knowledge Foundation in Sweden, the Wallenberg Autonomous Systems and Software Program (WASP), and the Industrial Excellence Center EASE - Embedded Applications Software Engineering444http://ease.cs.lth.se.