Cracking CAPTCHAs with ML

Ahmed Kamran, James Cavallo, and Kurt Ger

A robot solving a CAPTCHA (Generated using Dall-E)

Abstract

CAPTCHAs serve as a vital security measure to prevent unauthorized access and automated attacks on the internet. This paper presents a comprehensive machine-learning approach to solve various types of CAPTCHAs, specifically focusing on alphanumeric CAPTCHAs and Google reCAPTCHAs. We develop a complete pipeline that combines multiple models to classify and solve different CAPTCHA types. Our approach achieves over 80% validation accuracy for alphanumeric CAPTCHAs and demonstrates promising results for Google reCAPTCHAs. This paper highlights the potential vulnerabilities of CAPTCHAs and underscores the need for ongoing security enhancements.

Introduction

The internet has become an integral part of our daily lives, with a growing number of people and businesses relying on it for various purposes, such as communication, information sharing, and commerce. With this increased reliance on the internet comes a need for robust security measures to protect users and websites from unauthorized access, fraud, and abuse. One widely used security measure to protect websites and online services is the Completely Automated Public Turing test to tell Computers and Humans Apart (CAPTCHA). CAPTCHAs are designed to differentiate between human users and automated bots, ensuring that only genuine users have access to web applications, preventing Distributed Denial of Service (DDoS) attacks, and ensuring the authenticity of customers for online retailers among other uses.

The evolution of CAPTCHAs has been driven primarily by advances in artificial intelligence (AI), machine learning (ML), and computer vision techniques. As these technologies continue to develop, so must CAPTCHAs to maintain their efficacy as a security measure. In recent years, researchers have been exploring ways to break CAPTCHAs using various ML techniques, from image CAPTCHA attacked by convolutional neural nets (Zhou et al 2018) to text CAPTCHA resolved with shallow predictors (Bursztein 2011). This has led to the development of more complex and harder-to-solve CAPTCHA systems. This arms race between CAPTCHA designers and attackers is a continuous process, with both sides constantly improving their techniques to outpace the other.

This paper presents a comprehensive approach to solving different types of CAPTCHAs using machine learning. We focus on two main types of CAPTCHAs: alphanumeric CAPTCHAs, which require users to identify and input characters from a distorted image, and Google reCAPTCHAs, which require users to identify specific objects within a grid of images. Our goal is to test the limits of current CAPTCHA implementations, evaluate their robustness against our machine learning-based approaches, and potentially identify areas for improvement in CAPTCHA design and implementation.

The primary motivation behind our research is the increasing prevalence of AI, ML, and computer vision techniques in both academic and commercial settings. As these technologies become more accessible and sophisticated, there is a growing need for CAPTCHA systems to adapt and evolve in order to maintain their effectiveness as a security measure. By examining the current state of CAPTCHA security and the potential vulnerabilities that may be exploited by attackers, our research contributes to the ongoing effort to enhance and maintain the security of the internet.

Our study is organized as follows: We review related work in the field of CAPTCHA breaking, discussing previous attempts to solve different CAPTCHA types and the methodologies employed. We outline the methods used in our research, detailing our approach to solving alphanumeric CAPTCHAs, and Google reCAPTCHAs, as well as the pipeline we developed to integrate these techniques. We present the results of our experiments, reporting on the performance of our approach for each CAPTCHA type. We discuss the limitations and challenges we encountered during our research and potential future directions for our work. Finally, we conclude by summarizing our findings and their implications for CAPTCHA security.

As we proceed to explore the capabilities of machine learning in solving CAPTCHAs, we hope to shed light on the vulnerabilities of existing CAPTCHA systems, provide insights on potential improvements, and contribute to the ongoing effort to ensure the security and integrity of the internet. By testing the limits of CAPTCHA security, we aim to facilitate the development of more robust security measures that can withstand the rapidly evolving landscape of AI, machine learning, and computer vision. The challenges we encountered can also be informative for future work undertaking this task of CAPTCHA identification.

Related Work

The field of CAPTCHA breaking has a rich history of research, with numerous studies focusing on different types of CAPTCHAs and employing various machine learning techniques to solve them. In this section, we review some of the most relevant works that have informed our approach to solving alphanumeric CAPTCHAs and Google reCAPTCHAs.

Alphanumeric CAPTCHAs have long been a subject of interest for researchers aiming to evaluate the robustness of these security measures. One notable example is the Deep CAPTCHA project by Rezaei (2020), which employs Convolutional Neural Networks (CNNs) to solve text-based CAPTCHAs. The author utilized a multi-digit recognition model that achieved 90.06% accuracy on the test set in solving 5-digit alphanumeric CAPTCHAs, demonstrating the potential of deep learning techniques in breaking text-based CAPTCHAs. Our approach to solving alphanumeric CAPTCHAs is inspired by this work, but we have integrated our model into a broader pipeline to tackle various CAPTCHA types.

Google reCAPTCHAs, as a more recent development in CAPTCHA technology, have also attracted the attention of researchers. Our research aims to extend the literature on CAPTCHA solving by tackling this more modern form of CAPTCHA — image-based Google reCAPTCHAs, which require users to identify specific objects within a grid of images. The work of Zhou (2018) achieves 94.25% validation accuracy with a neural net modified from GoogLeNet, but focuses on a binary classification between what is and is not a road sign. We aim to generalize our pipeline to any puzzle that might be encountered.

To address the challenge of solving image-based reCAPTCHAs, we make use of the image segmentation dataset and pre-trained image segmentation model from CSAILVision (Zhou et al., 2017). This dataset, known as the ADE20K dataset, contains over 20,000 images annotated with pixel-level semantic labels, covering more than 150 object categories. We leverage this dataset and the associated pre-trained model to recognize objects within the reCAPTCHA images, allowing us to solve the challenges with high accuracy.

Our work builds upon previous research in CAPTCHA breaking, drawing inspiration from the Deep CAPTCHA project for solving alphanumeric CAPTCHAs and leveraging the MIT ADE20K dataset and pre-trained model from CSAILVision for Google reCAPTCHA breaking. By combining these techniques into a comprehensive pipeline, we aim to create a robust system capable of solving a wide range of CAPTCHA types, contributing to the ongoing effort to understand and improve CAPTCHA security.

Methods

In this section, we describe our methodology for solving various types of CAPTCHAs, including alphanumeric CAPTCHAs, Google reCAPTCHAs, and other CAPTCHA types. We also discuss the development of our CAPTCHA classifier and the complete pipeline that integrates our different models for solving CAPTCHAs.

• Alphanumeric CAPTCHA Classification

For solving alphanumeric CAPTCHAs, we developed a deep learning model using a Convolutional Neural Network (CNN) architecture. Our model, implemented in the notebook letter_captchas.ipynb, takes distorted images of alphanumeric characters as input and outputs the corresponding characters. The dataset used for training and validating our model, obtained from Kaggle, consists of 1070 CAPTCHA images, each containing a sequence of distorted characters (Fournier, 2018).

We preprocessed the images by loading them, reshaping them to the desired dimensions of 50 pixels in height, 200 pixels in width, and 3 color channels, and converting them to a floating-point representation. The pixel values were then normalized to a range between 0 and 1 using min-max normalization. From a total of 1070 examples in the dataset, we divided it into training and testing sets, with a 0.15 split ratio, resulting in 85% of the data used for training and the remaining 15% for testing. This split ensured that the model had sufficient training data while still being able to evaluate its performance on unseen examples.

Our CNN model consists of an input layer followed by three sets of convolutional layers, each with a kernel size of (5, 5), padding set to ‘same’, and the ReLU activation function. Each convolutional layer is followed by a max-pooling layer with a pool size of (2, 2). After the final max-pooling layer, we apply a dropout layer with a dropout rate of 0.3 to reduce overfitting. The network is then flattened and connected to a fully connected layer with 512 nodes and a ReLU activation function. Another dropout layer with a dropout rate of 0.3 is added before the output layers. The model has multiple output layers, one for each character in the CAPTCHA, each using a softmax activation function to obtain probability distributions over the character classes. This multi-output classification is what makes this model so successful. By generating a classification for each character, we can achieve far greater accuracy than if we generate one classification for the entire CAPTCHA.

• Google reCAPTCHA Classification

To solve Google reCAPTCHAs, we utilized a pre-trained image segmentation model from the MIT ADE20K dataset, implemented in the notebook recaptcha.ipynb. The ADE20K dataset comprises 25,574 training images and a further 2,000 validation images, annotated with pixel-level semantic labels, covering over 150 object categories. The pre-trained model used for our study is based on a deep learning architecture, which has demonstrated high performance in image segmentation tasks. We did not perform further fine-tuning of the pre-trained model but doing so could potentially improve our accuracy since the model is not specifically built for CAPTCHAs.

We preprocessed the reCAPTCHA images differently depending on the type of reCAPTCHA we were dealing with. If the CAPTCHA was a 3x3 grid of unique images, we cropped out each image and performed segmentation on it using the pre-trained model to see if it contained the target class name among the top predictions. If the CAPTCHA was one singular image on a 4x4 grid we performed image segmentation on the whole image, and identified which cells in the 4x4 grid contained the target class among the top predictions.

• Less successful approaches to reCAPTCHA identification

We initially approached the task of classifying reCAPTCHA images using a simple CNN with a few convolutional layers and treated the problem as an image classification task. We acquired a limited dataset of some image classes found in Google reCAPTCHAs on Kaggle, provided by Mazurov and Hossam (2022). However, due to the limited number of classes in the dataset, we could not generalize it to any CAPTCHA found in the wild. Furthermore, approaching this as an image classification task does not work since in an actual CAPTCHA the user has to click on segments of the larger image. Lastly, our CNN model achieved low accuracy (around 50%) for these CAPTCHA types, as detailed in the notebook image_captchas.ipynb. For these reasons, we ultimately switched to a segmentation-based approach using a pre-trained model.

• CAPTCHA Type Classifier

To create a comprehensive system capable of handling different types of CAPTCHAs, we developed a CAPTCHA classifier using a CNN model, implemented in the notebook captcha_type.ipynb. The classifier takes an input image and determines whether it is an alphanumeric CAPTCHA, a 3x3 reCAPTCHA, or a 4x4 reCAPTCHA. We used a dataset consisting of labeled images of different CAPTCHA types for training and validating the classifier. The training data for this model came from a combination of the data used in previous models.

We preprocessed the images by converting them to a fixed size of 120x120 pixels and maintaining their original color channels. The dataset was gathered by scraping the Google reCAPTCHA demo (Google, n.d.) using a web-scraper we built in scrape.ipynb. This scraper gave us 1334 CAPTCHA images scraped from Google, which when combined with our 1070 alphanumeric CAPTCHAs from Kaggle gave us our training and testing dataset. We used a 0.15 train/test split with 2043 training examples and 361 testing examples.

The architecture of our CAPTCHA classifier consists of three main blocks, each containing a convolutional layer with ReLU activation function, a max-pooling layer, a dropout layer with a dropout rate of 0.1, and a batch normalization layer. The first block uses 32 filters in the convolutional layer, the second block uses 64 filters, and the third block uses 128 filters. All convolutional layers have a 3x3 kernel size. After the third block, the model flattens the 3D feature maps into a 1D feature vector and applies a batch normalization layer.

Following the batch normalization layer, the classifier includes a series of fully connected layers with decreasing numbers of neurons: 256, 128, 64, 32, 16, and 8. Each fully connected layer has a ReLU activation function and is followed by a dropout layer with a dropout rate of 0.1. Finally, the model has an output layer with a softmax activation function, which outputs probability distributions over the CAPTCHA types. We trained the classifier using the sparse categorical cross-entropy loss function and the Adam optimizer, with default learning rate settings.

• Complete Pipeline

Our complete pipeline is implemented in the notebook main.ipynb, combining the alphanumeric CAPTCHA model, the reCAPTCHA classification model, and the CAPTCHA classifier to create a comprehensive system for solving various types of CAPTCHAs. The pipeline processes an input image as follows:

1. A Selenium-based web scraper navigates to the target website, launches the CAPTCHA, and extracts the CAPTCHA image.
2. The image is passed through the CAPTCHA classifier, which determines the type of CAPTCHA (alphanumeric, 3x3 reCAPTCHA, or 4x4 reCAPTCHA).
3. Depending on the identified CAPTCHA type, the image is sent to the corresponding model for solving.
4. The solution to the CAPTCHA is returned by the pipeline.
5. The web scraper then takes the model’s output and solves the CAPTCHA.

To build our models, we needed a diverse set of CAPTCHA images for training and testing purposes. For alphanumeric CAPTCHAs, we collected a large dataset of labeled CAPTCHA images from Kaggle and for Google reCAPTCHAs, we used web scraping to obtain images from the Google reCAPTCHA demo site (Google, n.d.). Additionally, we developed a CAPTCHA generator using the notebook gen_captcha.ipynb to create 3x3 CAPTCHA images for training purposes. The generator leverages the images available in the Kaggle dataset of image-based CAPTCHAs and crops them together in a 3x3 grid to create new CAPTCHA images.

• Evaluation Metrics

For the alphanumeric CAPTCHA model, we calculated the character-level accuracy, which measures the proportion of correctly classified characters in the CAPTCHA images. Our model achieved over 80% validation accuracy, demonstrating its effectiveness in solving alphanumeric CAPTCHAs.

For the Google reCAPTCHA classification model, due to the limited availability of testing data and the varying difficulty of reCAPTCHA challenges, it was difficult to numerically evaluate the model’s performance. However, by stitching together images in the Kaggle dataset we were able to construct a testing dataset with a limited number of classes to test the accuracy of our model.

For the CAPTCHA classifier and the complete pipeline, we used accuracy as the primary evaluation metric. The classifier achieved high accuracy in determining the type of CAPTCHA present in the input image, enabling the integration of our different models into a single pipeline. The performance of the complete pipeline was evaluated based on its ability to correctly solve various types of CAPTCHAs, with promising results observed for both alphanumeric CAPTCHAs and Google reCAPTCHAs.

Our methodology for solving different types of CAPTCHAs involved the development of multiple deep-learning models, a CAPTCHA classifier, and a complete pipeline that integrates the models to solve a diverse range of CAPTCHAs. Our models achieved high accuracy in solving alphanumeric CAPTCHAs and demonstrated promising results for Google reCAPTCHAs, contributing to the ongoing effort to understand and improve CAPTCHA security.

Results

In this section, we present the results of our experiments and evaluations for the various models and components developed in our study. We provide detailed performance metrics and analysis for the alphanumeric CAPTCHA model, the Google reCAPTCHA classification model, the CAPTCHA classifier, and the complete pipeline. Additionally, we discuss the limitations and challenges encountered during the evaluation of our models.

• Alphanumeric CAPTCHA Model

Our deep learning model for solving alphanumeric CAPTCHAs achieved a validation accuracy of 83.35%. The character-level accuracy indicates that our model is highly effective in recognizing and classifying distorted characters in CAPTCHA images. We observed that the model’s performance increased with the complexity and variety of the training data, highlighting the importance of data augmentation and preprocessing techniques in improving the model’s generalization capability.

• Google reCAPTCHA Classification Model

Evaluating the performance of our Google reCAPTCHA classification model proved to be challenging due to the limited availability of labeled reCAPTCHA data for testing. As a result, we relied on web scraping to collect a dataset of reCAPTCHA images for evaluation. Despite the limited testing data, our model demonstrated promising results when the reCAPTCHA prompt was included in the ADE20K dataset.

We generated a sample of 100, 3x3 CAPTCHAs using a limited set of classes from the Kaggle dataset (Fournier 2018). When tested on this smaller labeled dataset we had an average accuracy of 82.11%. This means that on average, the model can correctly identify 7 out of 9 cells in the 3x3 reCAPTCHA grid. We were not able to perform similar tests on 4x4 reCAPTCHAs because producing a labeled dataset with per-pixel segmentation of one image is much more challenging.

For reCAPTCHA prompts that did not match any object category in the dataset, the model crashed since it could not find the target class in its list of class names. This limitation highlights the need for expanding the number of classes in the dataset or developing alternative approaches to bridge the gap between reCAPTCHA prompts and the available object categories.

• CAPTCHA Type Classifier

Our CAPTCHA classifier achieved high accuracy in determining the type of CAPTCHA present in the input image. The classifier was able to distinguish between alphanumeric CAPTCHAs, 3x3 reCAPTCHAs, and 4x4 reCAPTCHAs with 99% accuracy. The performance of the classifier was consistent across different CAPTCHA types, indicating its effectiveness in identifying and classifying various types of CAPTCHAs.

• Complete Pipeline

The complete pipeline, which integrates the alphanumeric CAPTCHA model, the Google reCAPTCHA classification model, and the CAPTCHA classifier, demonstrated promising results in solving different types of CAPTCHAs. For alphanumeric CAPTCHAs, the pipeline achieved a high level of accuracy, successfully recognizing and classifying distorted characters in the images. For Google reCAPTCHAs, the pipeline was able to identify the presence of target objects based on the reCAPTCHA prompt, provided that the prompt was included in the ADE20K dataset.

During our evaluation, we identified some limitations and challenges associated with the pipeline, such as the need for additional object categories in the ADE20K dataset and the difficulty in bridging the gap between reCAPTCHA prompts and available object categories. These challenges could be addressed in future work by expanding the dataset, exploring alternative models or techniques, and refining the pipeline’s overall architecture.

Our study presents a comprehensive approach to solving various types of CAPTCHAs using machine learning models and a complete pipeline that integrates the models for a seamless classification process. Our models achieved high accuracy in solving alphanumeric CAPTCHAs and demonstrated promising results for Google reCAPTCHAs. The results of our experiments contribute to the ongoing effort to understand and improve CAPTCHA security, as well as highlight the potential of machine learning techniques in tackling this challenge.

• Limitations and Challenges

Despite the promising results achieved by our models and the complete pipeline, we encountered several limitations and challenges during the evaluation process. Some of these challenges include:

• Limited Testing Data: Evaluating the performance of the Google reCAPTCHA classification model proved to be difficult due to the limited availability of labeled reCAPTCHA data for testing. Collecting a larger dataset of labeled reCAPTCHA images could enable a more comprehensive evaluation of the model’s performance and facilitate further improvements.
• Dataset Expansion: The ADE20K dataset used for the Google reCAPTCHA classification model has a limited number of object categories, which sometimes resulted in the model’s inability to identify target objects that were not included in the dataset. Expanding the number of object classes in the dataset or exploring alternative datasets could help improve the model’s performance and its ability to solve a wider range of reCAPTCHA challenges.
• Character limitation: The alphanumeric CAPTCHA model encountered was built to identify CAPTCHAs with 5 letters/digits. CAPTCHAs with more letters will likely generate incorrect predictions. This limitation is a byproduct of our training data as we could only find extensive data for 5 letter captchas. Expanding this dataset with a diverse array of alphanumeric captchas and expanding the model’s architecture to predict longer sequences of characters will make this model more viable for real-world use cases.
• Pipeline Integration: The implementation of CAPTCHAs in websites can be complicated for our web scraper to navigate. We had to thoroughly analyze the HTML structure of the CAPTCHA implementations as well as how these websites use JavaScript to load CAPTCHA images. Our web scraper then had to be fine-tuned to be able to navigate the precise structure of the CAPTCHAs implemented on the target website.

Overall, our study demonstrates the potential of machine learning techniques in solving different types of CAPTCHAs, with promising results achieved for both alphanumeric CAPTCHAs and Google reCAPTCHAs. Addressing the limitations and challenges identified during our evaluation could pave the way for further improvements in CAPTCHA security and the development of more robust and effective solutions for combating automated threats on the internet.

Discussion

In this study, we explored the potential of machine learning techniques in solving different types of CAPTCHAs, with a focus on alphanumeric CAPTCHAs and Google reCAPTCHAs. Our results demonstrate the effectiveness of our models and the complete pipeline in tackling these challenges, contributing to the ongoing effort to understand and improve CAPTCHA security. In this section, we discuss the implications of our findings, the limitations encountered during our evaluation, and potential future work to address these challenges and enhance the performance of our models.

The high accuracy achieved by our alphanumeric CAPTCHA model highlights the effectiveness of deep learning techniques in recognizing and classifying distorted characters in CAPTCHA images. This finding has implications not only for CAPTCHA security but also for other applications that involve character recognition, such as optical character recognition (OCR) and handwriting recognition. Our model’s performance suggests that incorporating data augmentation and preprocessing techniques can significantly improve the generalization capability of deep learning models, which is essential for tackling a diverse range of character recognition challenges.

Our Google reCAPTCHA classification model, while facing limitations in terms of available testing data, demonstrated promising results when the reCAPTCHA prompt was included in the ADE20K dataset. This finding suggests that expanding the number of object classes in the dataset or exploring alternative datasets could help improve the model’s performance and its ability to solve a wider range of reCAPTCHA challenges. Furthermore, the challenges encountered in bridging the gap between reCAPTCHA prompts and available object categories highlight the potential of using additional pre-trained models or techniques, such as natural language processing (NLP) models from Hugging Face, to better understand and interpret reCAPTCHA prompts.

One potential avenue for enhancing our reCAPTCHA classification model is to utilize the Common Objects in Context (COCO) dataset (Lin et al., 2014). The COCO dataset is a widely-used resource containing a large number of labeled images across various object categories, with rich contextual information. By incorporating the COCO dataset into our training process, we could significantly expand the diversity of object categories and contextual scenarios our model is exposed to, ultimately improving its ability to recognize and classify objects within reCAPTCHA images. Additionally, the COCO dataset’s extensive annotations, including segmentation masks and keypoints, could further enhance our model’s understanding of object boundaries and relations, thereby increasing the overall performance in solving Google reCAPTCHAs.

The high accuracy achieved by our CAPTCHA classifier and the seamless integration of our models in the complete pipeline underscores the potential of machine learning techniques in solving various types of CAPTCHAs. The performance of our pipeline has implications for CAPTCHA security, as it demonstrates that machine learning models can effectively distinguish between different CAPTCHA types and solve them with high accuracy. This finding highlights the need for continuous improvement in CAPTCHA design and the development of more robust security measures to protect against automated threats on the internet.

Despite the promising results achieved by our models and the complete pipeline, we encountered several limitations and challenges during the evaluation process. These challenges include the limited availability of testing data for the Google reCAPTCHA classification model, the need for dataset expansion, and the difficulties in distinguishing between similar character classes in the alphanumeric CAPTCHA model. Addressing these challenges through the collection of more labeled data, the exploration of alternative datasets or models, and the refinement of our pipeline’s architecture could pave the way for further improvements in CAPTCHA security and the development of more robust and effective solutions for combating automated threats on the internet.

Our study demonstrates the potential of machine learning techniques in solving different types of CAPTCHAs and highlights the need for continuous research and development in this area. Future work could focus on addressing the limitations and challenges identified in our evaluation, as well as exploring alternative models and techniques for solving CAPTCHAs and other related challenges in the field of computer vision and machine learning.

Conclusion

This study presents a comprehensive approach to solving various types of CAPTCHAs using machine learning techniques, with a focus on alphanumeric CAPTCHAs and Google reCAPTCHAs. Our models achieved high accuracy in solving alphanumeric CAPTCHAs and demonstrated promising results for Google reCAPTCHAs, contributing to the ongoing effort to understand and improve CAPTCHA security. By addressing the limitations and challenges encountered during our evaluation, future work could pave the way for further advancements in CAPTCHA design, developing more robust security measures, and applying machine learning techniques in combating automated threats on the internet.

Citations

Bursztein, E., Martin, M., & Mitchell, J. (2011). Text-based CAPTCHA strengths and weaknesses. Proceedings of the 18th ACM Conference on Computer and Communications Security. https://doi.org/10.1145/2046707.2046724

Fournier, P. (2018). CAPTCHA Version 2 Images [Dataset]. Kaggle. Retrieved from https://www.kaggle.com/datasets/fournierp/captcha-version-2-images

Google. (n.d.). reCAPTCHA demo: Simple online demo. Retrieved from https://www.google.com/recaptcha/api2/demo

Lin, T.-Y., Maire, M., Belongie, S., Hays, J., Perona, P., Ramanan, D., Dollár, P., & Zitnick, C. L. (2014). Microsoft COCO: Common Objects in Context. In D. Fleet, T. Pajdla, B. Schiele, & T. Tuytelaars (Eds.), Computer Vision — ECCV 2014 (pp. 740–755). Springer International Publishing. https://doi.org/10.1007/978-3-319-10602-1_48

Mazurov, M., & Hossam, A. (2022, August). Google reCAPTCHA Image Dataset. Kaggle. Retrieved from https://www.kaggle.com/datasets/mikhailma/test-dataset

Rezaei, M. (2020). Deep CAPTCHA: A Deep Learning-based CAPTCHA Solver [Code repository]. GitHub. Retrieved from https://github.com/DrMahdiRezaei/Deep-CAPTCHA

Zhou, B., Zhao, H., Puig, X., Fidler, S., Barriuso, A., & Torralba, A. (2017). Scene Parsing through ADE20K Dataset [Code repository]. GitHub. Retrieved from https://github.com/CSAILVision/semantic-segmentation-pytorch

Zhou, Y., Yuan, Z., Liu, Y., & Yan, J. (2018). Breaking Google reCAPTCHA v2. Journal of Computing Sciences in Colleges, 34(1), 126–136. https://dl.acm.org/doi/abs/10.5555/3280489.3280510

Github

All notebooks mentioned in this paper in_this_format can be found in this GitHub repository.