http://reposit.library.du.ac.bd:8080/xmlui/xmlui/handle/123456789/302 Tue, 07 Apr 2026 09:03:04 GMT 2026-04-07T09:03:04Z http://reposit.library.du.ac.bd:8080/xmlui/xmlui/handle/123456789/4110 Ensemble Learning Algorithms for Classification Tasks in Natural Language Processing (NLP) Hossain, Afzal Natural Language Processing (NLP) encompasses a multitude of practical applications, including Information Retrieval, Information Extraction, Machine Translation, Text Simplification, Sentiment Analysis, Text Summarization, Spam Filtering, Auto-prediction, Auto-correction, Speech Recognition, Question Answering, and Natural Language Generation. Many of these applications are essentially classification tasks, which can be performed by machine learning models. Ensemble techniques within machine learning involve combining multiple models to improve predictive performance compared to individual models. This thesis explores the application of ensemble learning techniques to improve classification performance in NLP tasks. Various ensemble learning techniques, including bagging, boosting, random forest, and voting, are explored and experimented with. For each ensemble method, common base models, such as Support Vector Machines (SVM), Naive Bayes, Decision Trees, and K-Nearest Neighbor (KNN), are employed. Various evaluation metrics commonly used in NLP classification tasks are used, including accuracy, precision, recall, F1-score, and time complexity of the algorithms. The findings of the thesis suggest that ensemble methods, especially boosting, generally perform better than traditional machine learning methods for NLP classification tasks. The thesis also describes the modification of two ensemble models – firstly, majority voting is modified for the situation when a tie occurs, and secondly, bagging is modified with a different type of sampling. Both of these methods result in improved performances in the datasets. Overall, the research work provides a comprehensive overview of ensemble learning algorithms and their applications in improving classification performance in NLP tasks, backed by theoretical discussions, case studies, and experimental results. This thesis is submitted for the degree of Master of Philosophy. Sun, 20 Apr 2025 00:00:00 GMT http://reposit.library.du.ac.bd:8080/xmlui/xmlui/handle/123456789/4110 2025-04-20T00:00:00Z http://reposit.library.du.ac.bd:8080/xmlui/xmlui/handle/123456789/3438 A NOVEL BUG TRIAGING STRATEGY USING DEVELOPER RECOMMENDATION AND LOAD BALANCING MODEL Uddin, K. M. Aslam Bug triage is essential in efficiently assigning bugs to developers by leveraging past experiences. Without this crucial process, experienced developers may be inundated with assignments, while newer developers may be underutilized. Furthermore, improper bug distribution among different developer types can lead to various issues, including delays, errors, decreased capacity, and diminished job satisfaction. Previous bug triaging methods often do not account for newly joined developers, making them ineffective in recommending these developers for bug assignments. Consequently, these methods lead to improper task allocation, denying new team members valuable learning opportunities during bug resolution. Furthermore, prior research tends to overlook workload distribution among different developer categories, neglecting the need to balance bug assignments among experienced developers, newcomers, and those with varying skill levels. To address these issues, there is a need for an automated bug triaging technique that not only includes new developers but also prioritizes workload distribution among different developer categories. Therefore, this study introduces a novel bug triaging strategy that combines two pivotal models: Bug Solving Developer Recommendation Model (BSDRM) and Developer Scheduler (DevSched). The first model, known as the BSDRM, forms the core of automated bug triaging. BSDRM harnesses the power of Machine Learning (ML) algorithms and historical bug reports to intelligently suggest developers for specific bug resolution tasks. To achieve this, Eclipse, Mozilla, and NetBeans datasets are aggregated and split into training and testing sets. Subsequently, a sentence-embedded model is crafted from the training set, generating a developer-specific word repository. In contrast, the test set is transformed into a vocabulary list using an embedded model. BSDRM identifies eligible developers by matching their developer-specific word repository with the bug report vocabulary list via K-Nearest Neighbour (KNN) analysis. These developers are then categorized into three groups: experienced, newly experienced, and fresh graduate developers, utilizing a classification model comprising various ML algorithms Decision Tree (DT), Extra Tree (ET), AdaBoost (AdC), Bagging Classifier (BC), Gradient Boosting (GB), KNN, Nearest Centroid (NC), Bernoulli Na¨ıve Bayes (BNB), Multinomial Na¨ıve Bayes (MNB), Complement Na¨ıve iii Bayes (CoNB), Gaussian Na¨ıve Bayes (GNB), Logistic Regression (LR), Perceptron (Pr), and Multi-Layer Perceptron (MLP). Remarkably, the Bagging Classifier exhibits outstanding performance, achieving 96.59% accuracy in classifying developers with varying experience levels. In tandem with BSDRM, this study introduces the second model, DevSched, which assumes a critical role in balancing developer workloads. DevSched factors in workload distribution, developer proficiency, and bug characteristics. It generates multiple developer profiles based on historical bug reports and assigns bugs to developers by assessing the highest similarity between bug vectors and developer corpora. DevSched also dynamically adjusts developer workloads and refines their ratings based on performance. The study utilizes bug reports from Eclipse, Mozilla, and NetBeans to evaluate developer performance in the bug-triaging process. DevSched efficiently assigns and balances bugs among various developer categories, resulting in significantly reduced standard deviations for Eclipse, NetBeans, and Mozilla datasets compared to conventional bug distribution processes. This meticulous process is reiterated for each bug, ensuring optimal resource allocation and timely resolution of critical issues. The proposed study will collectively enhance bug resolution efficiency, optimize developer workloads, and ensure that both experienced and newer developers are judiciously utilized in the bug triaging process. A Thesis Submitted in Partial Fulfillment of the Requirements for the Degree of Master of Philosophy (MPhil). Sun, 17 Nov 2024 00:00:00 GMT http://reposit.library.du.ac.bd:8080/xmlui/xmlui/handle/123456789/3438 2024-11-17T00:00:00Z http://reposit.library.du.ac.bd:8080/xmlui/xmlui/handle/123456789/1651 AGILE SOFTWARE DEVELOPMENT TEAMWORK PRODUCTIVITY- A SYSTEM DYNAMICS APPROACH TO ANALYSE THE PRODUCTIVITY INFLUENCE FACTORS Fatema, Israt The agile method emphasizes the people factors and strength of teamwork that simplify the development process. A highly productive team throughout an agile software development process is very instrumental in achieving project success. Consequently, understanding of how individual behavior and productivity are affected by teamwork within an agile team becomes critical. Identifying factors that impact productivity will result in the improvement of teamwork. Hence, a need emerges to recognize the significant ones. Doing so will enable project team management to determine the areas where to concentrate efforts in order to improve productivity. Improvement in Agile Software Development (ASD) will not be achieved without considering that there is a large number of factors affecting agile teamwork productivity. The objective of this study is to explore what factors influence agile teamwork productivity, and how these factors interacted. This is achieved through a two-phase approach and the use of system dynamics as the modeling tool. The first phase involves reviewing relevant literature, performing a set of in-depth interviews with agile team members and conducting a survey to identify productivity factors. The second phase involves the construction of a System Dynamics (SD) model of agile teamwork productivity with the findings from the first phase to analyze the productivity influence factors. In the first phase, a survey has been administered to 60 respondents from 18 agile software companies in Bangladesh. The findings from the first phase reveal that from the perspective of agile team members, the most perceived factors impacting their productivity are motivation, team effectiveness, and team management. The culture of social hierarchy in a self- managed agile team obstructs implementation of agile practice. Although, the most followed organizational structure is horizontal, Scrum is leading agile practice among the participating companies. Lack of management support is found to be the most mentioned reason for any failed agile project. In the second phase, a system dynamics model of agile teamwork productivity is constructed to analyse the productivity influence factors. The complex interrelated structure of different factors affecting agile teamwork productivity is modelled using influence diagram, Causal Loop Diagram (CLD) and stock and flow diagram. The resulting model attempts to capture dynamic characteristics and nonlinearities of ASD teamwork productivity influence factors with an emphasis on the management of agile teamwork. Using the proposed model, the project manager may find the origin of a decrease in productivity, evaluate management strategies along with their effects on teamwork productivity. It also focuses on how well the simulations match the predictions from the theory and survey results from the first phase. This thesis submitted in partial fulfillment of the requirements for the degree of Master of Philosophy (MPhil). Wed, 09 Dec 2020 00:00:00 GMT http://reposit.library.du.ac.bd:8080/xmlui/xmlui/handle/123456789/1651 2020-12-09T00:00:00Z