Automated Code Review and Bug Detection

2024 19th International Joint Symposium on Artificial Intelligence and Natural Language Processing (iSAI-NLP) | 979-8-3315-0991-0/24/$31.00 ©2024 IEEE | DOI: 10.1109/iSAI-NLP64410.2024.10799479

Phang Justin Sheng Xuan Yunli Lee

School of Engineering and Technology Research Centre For Human-Machine Collaboration (HUMAC)
Sunway University School of Engineering and Technology
Selangor, Malaysia Sunway University
[email protected] Selangor, Malaysia
[email protected]

Abstract— With the increasing demand for efficient code reviews, In recent years, the integration of ML into
especially among beginner programmers, existing tools often lack development workflows has led to the creation of tools that
user-friendliness and fail to streamline error detection and correction offer higher levels of abstraction, helping developers manage
effectively. To address these gaps, this paper presents an Automated complexity while maintaining code quality. Tools like GitHub
Code Review and Bug Detection Tool designed to simplify the
identification and fixing of code errors. The tool features an intuitive
Copilot leverage machine learning to provide real-time code
graphical user interface (GUI) tailored for both novice and experienced suggestions, helping developers write code faster and with
programmers. Leveraging advanced machine learning models, it fewer errors. However, despite their popularity, these tools face
classifies errors and suggests code refinements, ensuring accurate and limitations. For instance, they often struggle with
efficient error detection. The development process involved customization, making it difficult for developers to tailor the
integrating machine learning algorithms for error classification within tools to their specific needs. Additionally, while these tools are
a streamlined GUI. Usability and effectiveness were assessed through powerful, they can be less beginner-friendly, creating a steep
feedback from 21 participants, highlighting the tool’s capability to learning curve for new programmers [2].
enhance programming accessibility and simplify the review process.
The successful implementation demonstrates the tool’s potential to
provide a user-friendly solution, contributing to more efficient
The demand for more accessible and customizable
programming practices and making code review accessible to a automated code review solutions is growing as developers seek
broader audience. tools that not only integrate seamlessly into their workflows but
also provide actionable insights tailored to their level of
Keywords— Machine-Learning, Code Review, Bug Detection, expertise. Machine learning offers the potential to address these
Automated needs by providing tools that can adapt to different
programming environments and skill levels, making automated
I. INTRODUCTION code reviews more efficient and accessible to a broader range
of developers.
The growing complexity of software development
necessitates efficient and reliable code review processes. As This project focuses on developing an Automated
codebases expand, maintaining quality and identifying bugs Code Review and Bug Detection Tool aimed at assisting
becomes increasingly challenging. Manual code reviews, beginner and intermediate programmers. The tool is designed
though thorough, are often time-consuming and prone to human to streamline code review processes, improve code quality, and
error, especially when dealing with large volumes of code. With provide educational insights by leveraging machine learning
around 20,000 daily code changes in major repositories [1], techniques. The core solution involves the use of advanced
relying solely on manual reviews is no longer feasible for machine learning models to detect code issues, classify errors,
sustaining high software quality. The demand for user-friendly and provide recommendations for code refinement. The
automated code review tools has surged, especially for beginner methodology includes a comprehensive review of existing
and intermediate programmers who often struggle with machine learning-based code review tools, followed by the
debugging. These users typically lack the extensive experience development and training of a custom ML model tailored to the
required to efficiently identify and correct errors in their code. needs of less experienced programmers. A user-friendly
graphical interface was also created to make the tool accessible
The rise of machine learning (ML) in software and intuitive for its target audience. The tool underwent system
development marks a significant shift towards more testing and iterative refinement, guided by feedback from user
sophisticated and automated code review processes. ML testing sessions.
models are capable of learning from vast amounts of code data,
enabling them to identify patterns, predict potential errors, and The paper aims to enhance software development for
suggest improvements. These capabilities allow ML-driven beginners by automating code reviews using machine learning,
tools to detect bugs and code smells that might be missed during focusing on bug detection and code quality assessment. The
manual reviews, significantly enhancing the accuracy and contributions of this project are significant in several areas.
efficiency of the review process. First, it offers a solution tailored to beginners and intermediate
programmers, who often struggle with existing tools that are
979-8-3315-0991-0/24/$31.00 ©2024 IEEE either too complex or not sufficiently informative. Second, the

Authorized licensed use limited to: SDM COLLEGE OF ENGINEERING AND TECHNOLOGY. Downloaded on April 01,2025 at 09:05:43 UTC from IEEE Xplore. Restrictions apply.
 tool's use of machine learning to automate error detection and machine learning algorithms for code review. Ahmad [6]
code refinement represents a step forward in making advanced explored a two-level code review process, focusing on internal
coding practices more accessible. Third, the project includes and external reviews. The internal reviews assessed
thorough documentation of the development process, providing functionality, design, and code clarity, while external reviews
valuable insights into the challenges and successes encountered focused on optimizing code for performance and functionality.
along the way. Overall, this paper contributes to the ongoing Using a Decision Tree algorithm, Ahmad developed a system
efforts to improve software development practices using that effectively classified and predicted code review outcomes,
machine learning, particularly in making these tools more emphasizing the importance of domain expertise and
accessible to a wider audience. systematic code evaluation.

B. Bug Detection with Machine Learning

II. RELATED WORKS
Saharudin et al. [7] conducted a systematic review of
In the realm of software engineering, two primary activities software bug prediction models, analyzing 31 primary studies
play a crucial role in ensuring the quality and reliability of from 2014 to 2020. Their review revealed common trends, such
software systems: code review and bug detection. These as the frequent use of datasets like NASA MDP and PROMISE
activities are foundational to maintaining high standards of and the application of machine learning techniques like Neural
code quality and facilitating early identification of defects. Networks and Bayesian Networks. The study highlighted the
Over the years, automated approaches to code review and bug relevance of CK Metrics, such as Coupling Between Objects
detection have evolved, addressing the growing complexity of (CBO) and Lines of Code (LOC), in bug prediction models.
software development and the need for efficiency in these Despite the potential of these models, the study noted the gap
processes. This section reviews the existing literature, between research findings and practical application, calling for
highlighting the methodologies, techniques, challenges, and more robust bug prediction models.
advancements in automated code review and bug detection, and
identifies the research gaps that motivate further contributions The methodologies employed in software engineering for
in this domain. bug detection play a crucial role in shaping software
development and maintenance. This section explores the
different approaches proposed by researchers for early bug
A. Code Review with Machine Learning detection, focusing on machine learning and deep learning
techniques.
Uchoa et al. [3] conducted a comprehensive study focusing
on predicting impactful changes in code reviews. By employing Siva et al. [8] proposed a machine learning-based
rigorous statistical tests and machine learning algorithms like methodology for bug detection, which unfolds in three stages:
Random Forest and Gradient Boosting, they analyzed data from data preprocessing, feature selection using Adaptive Artificial
seven systems, including Java systems from Eclipse and Jelly Optimization (A2JO), and bug prediction using a Long
Couchbase communities, to identify metrics that could predict Short-Term Memory (LSTM) classifier. Their approach
design degradation and code quality issues. Their findings achieved exceptional accuracy, demonstrating the potential of
emphasized the importance of both social and technical features LSTM and innovative feature selection techniques in bug
in predicting impactful changes during code reviews. Rahman prediction. Khalid et al. [9] enhanced the accuracy of bug
et al. [4] developed RevHelperRF, a predictive model aimed at detection models by employing K-means clustering for class
distinguishing between useful and non-useful code review label categorization and Particle Swarm Optimization for
comments. With 66% accuracy, their model, trained using model optimization. Their study showed that Support Vector
Random Forest, Logistic Regression, and Naïve Bayes, Machine (SVM) and its optimized version achieved the highest
demonstrated the potential for improving code review quality. accuracy, highlighting the effectiveness of these techniques in
The study highlighted the influence of code authorship and bug detection.
reviewer experience on the perceived value of review
comments, underscoring the importance of these social factors Hammouri et al. [10] evaluated the performance of three
in the code review process. supervised machine learning algorithms—Naïve Bayes,
Decision Tree, and Artificial Neural Networks (ANNs)—in
Rahman et al. [5] extended their research on code review predicting software faults. Their findings indicated that
comments by manually annotating 13,557 comments from Decision Trees consistently yielded the highest F-measure
GitHub repositories and applying machine learning techniques. value, reinforcing the utility of machine learning algorithms in
The study identified Linear Support Vector Classifier (SVC) as software quality improvement. Harzevili et al. [11] investigated
the most accurate method for analyzing review comments. the effectiveness of static bug detectors in uncovering real-
They also employed a Decision Tree-based approach using world security bugs in machine learning libraries. Their study
Gerrit, an internal code review tool, to classify review revealed that while tools like Flawfinder and RATS could
comments, providing insights into the effectiveness of different detect some bugs, their overall effectiveness was limited,

Authorized licensed use limited to: SDM COLLEGE OF ENGINEERING AND TECHNOLOGY. Downloaded on April 01,2025 at 09:05:43 UTC from IEEE Xplore. Restrictions apply.
 emphasizing the need for improved detection strategies tailored deliberately crafted examples that contain common
to machine learning applications. programming errors, such as syntax errors, logical flaws, and
violations of coding conventions. This classification is crucial
for the model's ability to learn from both correct and incorrect
III. METHODOLOGY examples.

This project focused on developing and evaluating a Table 1 shows the features used in each dataset.
machine learning model for predicting and refining code errors. Features were extracted from the datasets for error
The methodology included four main stages: data collection, classification and code refinement tasks. Custom dataset
model training, model evaluation, and usability testing. A classes were used for tokenization and encoding, preparing the
dataset of code snippets with corresponding error messages was data for model input.
collected, and a pre-trained T5 model was fine-tuned for error B. Model Training
prediction and code refinement using supervised learning. The
model’s performance was assessed using accuracy metrics and
• CodeBERT: A bimodal pre-trained model based on
qualitative analysis, and a usability survey gathered feedback
the RoBERTa architecture, fine-tuned for error
on the model's effectiveness and ease of integration.
classification using a hybrid objective function
combining masked language modeling (MLM) and
A. Data Preparations replaced token detection.
• Refined CodeT5: A model based on the T5
Two primary datasets were used: a Python3 code dataset architecture, fine-tuned for code sequence-to-
from Yasunaga and Liang [12] with 3 million snippets, and a sequence tasks, particularly code generation and
dataset from Bisht [13] with intentionally modified code errors. refinement.
These datasets were preprocessed through tokenization,
anonymization, and error mapping to ensure consistency for For the application, there will be two models used in
model training. The inclusion of diverse datasets is essential to training, the CodeBERT model will be used for the
ensure the model can generalize well across different coding classification task, specifically for identifying and classifying
scenarios. Furthermore, the data collection process involved errors within a code snippet while the CodeT5 model will be
careful selection and preprocessing of snippets to maintain used for the Seq2Seq task, thus providing solutions or
consistency and reliability for model training. improvements for the code snippet provided.

Regarding the dataset from Bisht [13] due to the lack of The CodeBERT model was fine-tuned for code
error-based code snippets, a script was introduced to purposely classification with an 80-20 train-validation split. The training
embed errors within the code snippets, such as: utilized the AdamW optimizer with a learning rate of 2e-5 and
• expected an indented block weight decay of 0.01, along with a linear learning rate
• invalid syntax scheduler. To address class imbalance, a weighted random
sampler was employed, and the model was trained for three
• unbalanced (){}[]
epochs with a batch size of 8. Tokenization was performed
• unexpected indent using the RobertaTokenizer, and gradient clipping with a max
• unexpected unindent norm of 1.0 was applied to ensure stable training. After each
• unindent does not match any outer indentation level epoch, the model's performance was evaluated on the validation
set, and the best-performing model was saved. The entire
Table 1: Features used in each dataset process, including loss and accuracy metrics, was logged using
Source Dataset Features Description of Dataset TensorBoard, allowing for detailed monitoring and analysis of
Used
Yasunaga Good Code Code string Code snippets without
the training progress. CodeBERT utilizes a bimodal setup to
and Liang errors process both natural language and code. It was fine-tuned for
[12] Bad Code Code string, Code snippets containing error classification, where the model classifies code snippets as
error object errors and their labels either correct or erroneous, using Masked Language Modeling
Bisht [13] Good Code Code string Code snippets without (MLM) and Replaced Token Detection (RTD) to improve its
errors
Bad Code Code string Code snippets containing ability to identify errors.
with errors multiple errors
embedded The refined CodeT5 model was trained on a dataset of code
snippets for buggy code repair. It begins by loading two
The datasets used in this study consist of code snippets datasets and extracting input-output pairs for training. The
classified as either "good" or "bad." "Good" code snippets are model was trained on code pairs, where the input was a buggy
defined as those that are syntactically correct and adhere to best snippet, and the output was the corrected version. The training
practices in coding. In contrast, "bad" code snippets are goal was to minimize the difference between the predicted and

Authorized licensed use limited to: SDM COLLEGE OF ENGINEERING AND TECHNOLOGY. Downloaded on April 01,2025 at 09:05:43 UTC from IEEE Xplore. Restrictions apply.
 correct code, focusing on syntax and semantic understanding of The tool analyzed the code, identified potential errors, and
programming languages. The data is split into training and provided classification results along with probabilities for each
validation sets, and a custom CodeDataset class is defined to class. While effective for experienced programmers, the CLI's
handle tokenization using the CodeT5 tokenizer. The model, complexity proved challenging for new programmers, the
tokenizer, and optimizer are initialized, with a linear learning primary target audience, who preferred a more user-friendly
rate scheduler and mixed precision training for efficiency. The interface and concise error feedback.
training loop incorporates gradient accumulation, learning rate
scheduling, and early stopping based on validation loss. The
model's performance is evaluated using BLEU, ROUGE, and
METEOR metrics on the validation set, and the best model is
saved for later use. The script emphasizes model checkpointing
to save the best-performing model during training.
Several optimizations were applied to enhance
performance. In CodeBERT, a weighted random sampler
addressed class imbalance, and gradient clipping prevented
exploding gradients during backpropagation. In CodeT5,
gradient accumulation simulated larger batch sizes without
exceeding memory limits, while mixed precision training
improved efficiency. Early stopping based on validation loss
was also implemented to prevent overfitting. Fig. 1. Using the Pre-Testing Version

E. Post-Testing Version
C. Evaluation
The latest version features a transition to a graphical user
Both models were evaluated using validation loss, BLEU, interface (GUI) as shown in Fig. 2, significantly enhancing
ROUGE, and METEOR scores. The model with the best usability. The GUI allows users to input code or upload files
validation performance was saved for deployment, ensuring easily, streamlining the interaction process. The output section
optimal accuracy and reliability in code generation tasks. now displays predicted errors and suggested code refinements
directly within the application, focusing on actionable insights
Throughout training, the model with the best validation rather than detailed class probabilities.
performance is saved to ensure that the most effective version
is preserved. This involves saving the model that achieves the
lowest validation loss or the highest metric scores, depending
on the evaluation criteria. Both CodeBERT and CodeT5 utilize
this approach to ensure that the optimal model is available for
deployment, thus providing reliable and high-quality code
generation in real-world applications.

In the system testing phase, the classification model was

evaluated using a dataset of 30 good and 30 bad code snippets.
The bad code snippets were categorized into seven distinct error
types: syntax errors, indentation errors, unbalanced
parentheses, logical errors, variable naming issues, type errors,
and import errors. This categorization was vital for assessing
the model's performance across different types of common
coding mistakes. The test set, compiled separately from the
training datasets, was randomly selected from various GitHub
repositories and includes diverse error types similar to those
found in real-world coding scenarios, ensuring a
comprehensive evaluation of model accuracy and Fig. 2. Using the Post-Testing Version
generalizability.
IV. RESULTS AND DISCUSSION
D. Pre-Testing Version A. System Testing

Initially, the tool was developed as a command-line The classification model was tested on a dataset of 30
interface (CLI) application as shown in Fig.1. Users could input good and 30 bad code snippets. Table 2 shows the confusion
code snippets directly or provide a file path to a Python script. matrix for the proposed classification model. It correctly

Authorized licensed use limited to: SDM COLLEGE OF ENGINEERING AND TECHNOLOGY. Downloaded on April 01,2025 at 09:05:43 UTC from IEEE Xplore. Restrictions apply.
 classified all good code snippets and 24 out of 30 bad snippets. interest in refining the recommendations further, specifically
Misclassification occurred in 6 instances of bad code. Further for more advanced coding scenarios.
testing on 56 snippets across 7 error categories (shown in Data
Preparations) showed 35 correct classifications, 10 Despite these critiques, the tool’s overall usability
misclassified errors, and 11 false negatives. received favorable reviews, with most participants appreciating
its clarity and speed. However, there were several suggestions
Table 2: Confusion Matrix for Model Classification for improvement, particularly around enhancing the UI for
Actual Positive Actual Negative better navigation and aesthetic appeal, providing clearer
Predicted Positive 30 6
Predicted Negative 0 24
instructions for file path formats, and expanding support to
additional programming languages beyond Python. These
Misclassifications often involved closely related error insights suggest that while the tool is effective, certain
categories, highlighting areas for improvement in error refinements could improve its accessibility and user experience
detection. for a broader range of programmers.

The Seq2Seq code repair model was evaluated using C. Current Issues
56 code snippets. Results in Table 3 showed that 45 snippets
were successfully repaired, 7 were partially repaired, and 4 The Automated Code Review and Bug Detection Tool
were incorrectly repaired. has shown considerable promise in accurately classifying and
Table 3: Overall Results from the Model Classification identifying code errors, particularly in Python. However, it has
Good Decent Bad some limitations that need addressing to enhance its
No. of Count 45 7 4 effectiveness. One notable issue is that the classification model,
while adept at identifying single errors in a code snippet,
Ratings in Table 3 are categorized as “Good”, struggles with detecting multiple errors simultaneously. This
“Decent”, and “Bad”, representing varying levels of limitation can hinder its utility in complex debugging scenarios
performance based on feedback scores. “Good” indicates a where multiple issues need to be resolved at once.
highly accurate classification, “Decent” signifies an adequate
but improvable level, and “Bad” points to low accuracy Additionally, the model sometimes misclassifies
requiring substantial improvement. These categories help errors due to the similarities in certain error messages, such as
standardize feedback interpretation. While the model "unexpected unindent" and "unexpected indent." These errors
demonstrated strong repair capabilities, the presence of are closely related in terms of context, leading the model to
"decent" and "bad" repairs indicated room for improvement. occasionally confuse one for the other. This misclassification
The tool's model performance is satisfactory, with classification highlights the need for further refinement of the model to
accuracy exceeding 70% and the seq2seq model yielding improve its accuracy in distinguishing between subtle
acceptable results 80% of the time. differences in error types. Addressing these issues, along with
expanding language support, optimizing performance, and
B. User Testing enhancing the user interface, will be crucial in making the tool
more robust and user-friendly, particularly for beginner
programmers who rely on clear and accurate feedback.
In the user testing phase, 21 participants, primarily
from the 18-24 age group, provided feedback on the Automated
Code Review and Bug Detection tool. Ratings for the tool’s V. CONCLUSION
accuracy and relevance of error classification, as well as code
refinement suggestions, were largely positive, with most
The development and testing of the Automated Code
participants giving scores between 4 and 5. Beginners and
Review and Bug Detection Tool has been highly rewarding.
advanced users expressed high confidence in the tool, while
The initial CLI-based version, while functional, revealed
intermediate users offered more critical feedback, particularly
significant areas for improvement in accessibility and interface
regarding the relevance of error messages and the classification
design. The introduction of a graphical user interface (GUI) in
of complex code issues. Beginners predominantly rated
the updated version has greatly enhanced the tool's usability and
accuracy at 4 and 5. Intermediate users showed slightly more
appeal, addressing key concerns raised during user testing. The
variability with 3 ratings by 3 participants, while advanced
GUI has further improved usability and convenience for the
users rated it similarly.
average user.
Users evaluated the relevance of the tool’s
recommendations for code refinement, rating them from 3 to 5, The literature review, including studies by Uchoa et al.
with most intermediate and advanced users rating them as 4 or [3] and Rahman et al. [4][5], provided valuable insights into the
5. Additionally, in the open-ended feedback, users expressed current landscape of machine learning code review tools. These
studies emphasize the need for advanced, user-friendly tools
capable of effectively analyzing code snippets, predicting

Authorized licensed use limited to: SDM COLLEGE OF ENGINEERING AND TECHNOLOGY. Downloaded on April 01,2025 at 09:05:43 UTC from IEEE Xplore. Restrictions apply.
 impactful changes, and improving code quality, aligning with [3] A. Uchoa et al., “Predicting design impactful changes
the goals of this paper. in modern code review: A large-scale empirical study,”
in 2021 IEEE/ACM 18th International Conference on
A notable difference between our Automated Code Mining Software Repositories (MSR), 2021.
Review and Bug Detection Tool and existing tools like GitHub
Copilot is the focus on structured error feedback and correction. [4] M. M. Rahman, C. K. Roy, and R. G. Kula, “Predicting
GitHub Copilot excels at code completion and suggestion tasks usefulness of code review comments using textual
but does not provide detailed guidance when errors occur. In features and developer experience,” in 2017
contrast, our tool offers a structured two-step process where IEEE/ACM 14th International Conference on Mining
errors are not only identified but also corrected with specific Software Repositories (MSR), 2017.
advice tailored to the user’s level of expertise. When GitHub [5] S. Rahman, U. A. Koana, H. K. Shanto, M. Akter, A.
Copilot encounters an error, it typically attempts to auto
Masood, and C. Roy, “Measuring the effectiveness of
complete or suggest an alternative code solution without
explaining the underlying issue. This can lead to a 'black box' code review comments in GitHub repositories: A
experience for beginner users, where they fix errors without machine learning approach,” in The 16th Machine
understanding the reasons behind them. Our tool, however, Learning and Data Mining in Pattern Recognition,
explicitly classifies the type of error (e.g., 'Expected an indented 2020, pp. 35–48.
block,' 'Invalid syntax'), and then CodeT5 provides actionable [6] M. W. Ahmad, “Automatic code review effectiveness
suggestions for correction, accompanied by explanations.
detection,” United International University, 2020.
User feedback has been instrumental in shaping the [7] S. N. Saharudin, K. T. Wei, and K. S. Na, “Machine
final product. The new GUI has made the tool more accessible, learning techniques for software bug prediction: A
especially for beginners, and has refined the output to better systematic review,” J. Comput. Sci., vol. 16, no. 11,
meet user needs. However, there are still areas for further pp. 1558–1569, 2020.
enhancement, including support for additional programming [8] R. Siva, Kaliraj, B. Hariharan, and N. Premkumar,
languages, improved processing speed, and further UI “Automatic software bug prediction using adaptive
refinement. While the current work focuses on error prediction
artificial jelly optimization with long short-term
and code refinement, future efforts will aim at integrating
security vulnerability detection into the system. Tools like memory,” Wirel. Pers. Commun., vol. 132, no. 3, pp.
Static Application Security Testing (SAST) can be incorporated 1975–1998, 2023.
alongside the models to flag common security issues, such as [9] A. Khalid, G. Badshah, N. Ayub, M. Shiraz, and M.
SQL injection vulnerabilities or cross-site scripting (XSS), Ghouse, “Software defect prediction analysis using
thereby providing a more comprehensive solution for machine learning techniques,” Sustainability, vol. 15,
automated code review.
no. 6, p. 5517, 2023.
In conclusion, this paper highlights the development [10] A. Hammouri, M. Hammad, M. Alnabhan, and F.
of an Automated Code Review Tool tailored specifically for Alsarayrah, “Software Bug Prediction using Machine
beginner and intermediate programmers. By addressing the Learning Approach,” International Journal of
unique challenges faced by these user groups, the tool not only Advanced Computer Science and
enhances their coding experience but also facilitates a deeper Applications(ijacsa), vol. 9, no. 2, 2018.
understanding of programming concepts. Future work will [11] N. S. Harzevili, J. Shin, J. Wang, S. Wang, and N.
focus on expanding the tool's capabilities to support additional
programming languages and further refining its usability based Nagappan, “Automatic static bug detection for
on user feedback. machine learning libraries: Are we there yet?,” arXiv
[cs.SE], 2023.
REFERENCES [12] M. Yasunaga and P. Liang, “Break-it-Fix-it:
Unsupervised learning for program repair,” arXiv
[1] Y. Yin, Y. Zhao, Y. Sun, and C. Chen, “Automatic code [cs.LG], 2021.
review by learning the structure information of code [13] T. Bisht,
graph,” Sensors (Basel), vol. 23, no. 5, 2023. “Iamtarun/python_code_instructions_18k_alpaca ·
[2] B. Zhang, P. Liang, X. Zhou, A. Ahmad, and M. datasets at hugging face,” Huggingface.co, 2023.
Waseem, “Practices and challenges of using GitHub [Online]. Available:
copilot: An empirical study,” in International https://huggingface.co/datasets/iamtarun/python_cod
Conferences on Software Engineering and Knowledge e_instructions_18k_alpaca. [Accessed: 28-Sep-2024]
Engineering, 2023, vol. 2023, pp. 124–129.

Authorized licensed use limited to: SDM COLLEGE OF ENGINEERING AND TECHNOLOGY. Downloaded on April 01,2025 at 09:05:43 UTC from IEEE Xplore. Restrictions apply.