CarcassFormer: an end-to-end transformer-based framework for simultaneous localization, segmentation and classification of poultry carcass defect

Abstract

In the food industry, assessing the quality of poultry carcasses during processing is a crucial step. This study proposes an effective approach for automating the assessment of carcass quality without requiring skilled labor or inspector involvement. The proposed system is based on machine learning (ML) and computer vision (CV) techniques, enabling automated defect detection and carcass quality assessment. To this end, an end-to-end framework called CarcassFormer is introduced. It is built upon a Transformer-based architecture designed to effectively extract visual representations while simultaneously detecting, segmenting, and classifying poultry carcass defects. Our proposed framework is capable of analyzing imperfections resulting from production and transport welfare issues, as well as processing plant stunner, scalder, picker, and other equipment malfunctions.

To benchmark the framework, a dataset of 7,321 images was initially acquired, which contained both single and multiple carcasses per image. In this study, the performance of the CarcassFormer system is compared with other state-of-the-art (SOTA) approaches for both classification, detection, and segmentation tasks. Through extensive quantitative experiments, our framework consistently outperforms existing methods, demonstrating re- markable improvements across various evaluation metrics such as AP, AP@50, and AP@75. Furthermore, the qualitative results highlight the strengths of CarcassFormer in capturing fine details, including feathers, and accurately localizing and segmenting carcasses with high precision. To facilitate further research and collaboration, the source code and trained models will be made publicly available upon acceptance.

INTRODUCTION

Increased consumption of poultry products will be a certainty for global food security achievement in the upcoming 30 y based on the efficiency of the utilization of poultry, as well as diverse consumer acceptance. The Food and Agriculture Organization of the United Nations 2005/2007 has projected that production of poultry will increase more than 100 percent by the year 2050 with an increased tonnage of poultry products, primarily broiler chickens, surpassing 180 million tons, with current projection estimated at just over 80 million tons Alexandratos and Bruinsma (2012). Numerous studies have demonstrated increasing annual poultry consummation rates, mainly due to relatively inexpensive price, nutritional value, and health benefits Elam (2022). In the U.S., broiler chicken efficiency of feed utilization has increased 7% from 2021 to the present at a similar slaughter age between 47 and 48 d across the decade Council (March 18, 2021). With annualized increases in broiler production, concomitant increases in labor are necessary for meat production supply chain efficiency. In addition to the costs of increased workforce labor and workforce development, many poultry companies are suffering from labor shortages Kaminski (2020); Wu et al. (2022). Another negative side of relying on people for the process of poultry processing represents the varying results of carcass evaluation consistency. Thus, many companies use assembly lines stationed by employees to inspect the quality of chicken carcasses, which leaves room for human error and can result in miscategorized carcass defections. As a result, numerous agriculture industries, including poultry production facilities and poultry processing plant factories, are researching and investing in automated robotic technologies to improve processing and labor wellbeing, as well as profit Ren et al. (2020); Ahlin (2022); Park et al. (2022). Further, there are numerous automation technologies offering noticeable economic benefits to agricultural production as of late Jin et al. (2021).

In the era of precision agriculture, Machine Learning (ML) and Computer Vision (CV) have emerged as high-performance computing technologies that are creating new opportunities to improve broiler management, production, and identification of processing defects with non-invasive low-cost techniques Aydin (2017); Caldas-Cueva et al. (2021). In this study, the focus was on utilizing modern ML & CV, that is, Deep Learning, to analyze chicken carcasses after scalding, picking, and removal of head and feet in processing plants. Visual inspection is one of the most basic but also most important steps in controlling meat quality before the product is prepared, packaged, and distributed to the market. The image processing and classification within the poultry processing plants can optimize such systems, in addition to heightening food safety. Hence, our proposed intelligent and automated system will analyze and improve poultry processing concomitantly with increased data acquisition. Our computer vision system functions as an automated detection model capable of classifying defects and contaminated carcasses. While detection, segmentation, and classification are widespread tasks in computer vision Dong et al. (2021); Zhou et al. (2021); Le et al. (2022), they have focused on various tasks such as autonomous driving Le et al. (2017b,c); Janai et al. (2020); Tong et al. (2020); Truong et al. (2022); Nguyen et al. (2022), surveillance Gabeur et al. (2020); Wray et al. (2021); Yamazaki et al. (2022); Vo et al. (2022), biometrics Le and Savvides (2016); Le et al. (2017a); Duong et al. (2019a,b); Quach et al. (2022), and medical imaging Han et al. (2017); Le et al. (2018); Tran et al. (2022b); Le et al. (2023); Thang Pham et al. (2023); Nguyen et al. (2023), amodal understanding Tran et al. (2022a) which mainly target humans, car, objects, face, human organs. None of them target analyzing poultry carcass condemnations defects. One of the main reasons is the lack of publicly available data.

In the context of poultry carcass analysis, distinguishing between single and multiple carcasses in an image is a crucial step for accurate quality assessment. To achieve this, the problem was approached as an instance segmentation task, involving the localization of individual instances. Additionally, mask classification was performed to determine whether a single poultry carcass was defective or not. While per-pixel classification (e.g., FCN Long et al. (2015), Unet-based approaches Ronneberger et al. (2015); Zhou et al. (2018); Ibtehaz and Rahman (2020); Le et al. (2021); Tran et al. (2022b)) applies a classification loss to each output pixel and partitions an image into regions of different classes, mask classification (e.g., Mask-RCNN He et al. (2017), DETR Zhu et al. (2020)) predicts a set of binary masks, each associated with a single class prediction. In recent years, there has been a significant growth in the adoption of Transformer architecture Vaswani et al. (2017) for semantic segmentation tasks. This trend is underscored by numerous approaches that have leveraged Transformer models, demonstrating state-of-the-art performance in the field. Notable examples include DETR Carion et al. (2020), SegFormer Xie et al. (2021), Mask2Former Cheng et al. (2022), FASeg He et al. (2023a), and Mask DINO Li et al. (2023). In this paper, the question of how to simultaneously handle both mask classification and pixel-level classification is addressed. To address the aforementioned question, we particularly leverage the recent Transformer technique Vaswani et al. (2017) and propose CarcassFormer, which aims to simultaneously localize poultry carcasses from moving shackles, segment the poultry carcass body, and classify defects or contaminated carcasses. To develop CarcassFormer, an experiment was set up at the University of Arkansas-Agricultural Experiment Station Pilot Processing Plant on the poultry research farm by placing a camera adjacent to the shackles of carcasses moving along a processing line. Each poultry carcass in the view of the camera will be analyzed by localizing with a bounding box, segmenting the boundary, and classifying to determine its imperfections. Any unapproved birds are then reworked. Notably, a bird is considered to be defective if it has one of the following issues: feathers, un-clean/dirty, skin peel, broken wings, or broken legs. The annotation requirement is following instructions provided by USAD USDA.

Our contribution is 3-fold as follows:

• •Dataset: A dataset containing a total of 7,321 images of poultry carcasses on a Pilot processing plant. The images in this diverse dataset contain real-world examples of chickens of a range of ages, sizes, and numbers of chickens per frame. The dataset has been carefully annotated by 3 experts.
• •Methodology: We propose CarcassFormer, an effective end-to-end Transformer-based framework for simultaneously localizing poultry carcass regions, segmenting car- cass areas, and determining carcasses with imperfections. CarcassFormer is based on Transformer-based Unet architecture.
• •Pretrained Models and Code: We will release our pre-trained model and source code of CarcassFormer for research purposes.

Related Work

Image Segmentation

Image segmentation is a critical computer vision task that involves dividing an image into different regions based on visual features. This process can be accomplished through either semantic segmentation or instance segmentation. Semantic segmentation categorizes pixels into multiple classes, for example, foreground and background, but does not differentiate between different object instances of the same class. Popular semantic segmentation models include the Fully Convolutional Network (FCN) Long et al. (2015) and its variants, such as the U-Net family Ronneberger et al. (2015); Zhou et al. (2018); Ibtehaz and Rahman (2020); Le et al. (2021), as well as the Pyramid Scene Parsing Network (PSPNet) Zhao et al. (2017) and DeepLabV3 Chen et al. (2018).

In contrast, instance segmentation aims to detect and segment individual objects by providing a unique segmentation mask for each object. There are 2 types of instance segmentation approaches: 2-stage and 1-stage methods. Two-stage approaches, such as top-down Cai and Vasconcelos (2018); Chen et al. (2019); Cheng et al. (2020) and bottom-up methods Arnab and Torr (2016); Chen et al. (2017); Newell et al. (2017), detect bounding boxes first and then perform segmentation within each region of interest. On the other hand, one-stage approaches, such as anchor-based methods Li et al. (2017); Bolya et al. (2019) and anchor-free methods Ying et al. (2019); Chen et al. (2020); Lee and Park (2020), perform both detection and segmentation simultaneously, resulting in less time consumption. Anchor-based one-stage approaches generate class-agnostic candidate masks on candidate regions and extract instances from a semantic branch. However, these approaches rely heavily on predefined anchors, which are sensitive to hyper-parameters. To address this issue, anchor-free one-stage methods eliminate anchor boxes and use corner/center points instead. Moreover, based on their feature backbone and learning mechanism, various approaches to instance segmentation can be categorized into either Convolution Neural Network (CNN)- based or Transformer-based approaches as follows.

CNN-Based Instance Segmentation

The idea of “detect then segment” has dominated in instance segmentation task, which is a 2-stage method. In particular, Mask R-CNN He et al. (2017) is the most representative work. Based on the priority of detection and segmentation, there are 2 groups in this category: top-down methods and bottom-up methods. The former first predicts a bounding box for each object and then generates an instance mask within each bounding box O Pinheiro et al. (2015); He et al. (2017). On the other hand, the latter associates pixel-level projection with each object instance and adopts a postprocessing procedure to distinguish each instance Arnab and Torr (2016); Kong and Fowlkes (2018). While the top-down methods mainly rely on the detection results and are prone to systematic artifacts on an overlap- ping instance, the bottom-up methods depend on the performances of postprocessing and tend to suffer from undersegment or over-segment problems Fathi et al. (2017). With a large amount of pixel-wise mask annotations, fully-supervised learning instance segmentation methods have achieved great performance. However, pixel-wise mask annotating is labor intensive (e.g., 22 h to label 1,000 segmentation masks Lin et al. (2014)). Thus, weakly-supervised Zhu et al. (2016); Zhou (2018) and semisupervised Van Engelen and Hoos (2020) have been proposed. CNN-based image segmentation has been outreached in multiple Computer Vision tasks including amodal segmentation Li and Malik (2016), salient detection Fan et al. (2019), human segmentation Zhang et al. (2019), soft biometrics Luu et al. (2016). CNN-based instance segmentation survey can be found at Hafiz and Bhat (2020); Gu et al. (2022).

Transformer in Computer Vision

Transformer was first introduced by Vaswani et al. (2017) for language translation and obtained State-Of-The-Art (SOTA) results in many other language processing tasks. Recently, many models Carion et al. (2020), Liu et al. (2022), Li et al. (2022) successfully applied the Transformer concept to computer vision and achieved promising performance. The core idea behind transformer architecture Vaswani et al. (2017) is the self-attention mechanism to capture long-range relationships. It has obtained state-of-the-art in many Natural Language Processing (NLP) tasks. Besides, Transformers have worked well suited for parallelization, facilitating training on large datasets Transformer has been successfully applied to enrich global information in various tasks in Computer Vision such as image recognition Dosovitskiy et al. (2020); Touvron et al. (2021) object detection Carion et al. (2020); Zhu et al. (2020); Sun et al. (2021), image segmentation Ye et al. (2019); Zheng et al. (2021); Tran et al. (2022a), action localization Vo et al. (2021, 2022), video captioning Yamazaki et al. (2022, 2023). DETR Zhu et al. (2020) is the first model that uses Transformer as an end-to-end and query-based object detector, with bipartite-matching loss and set prediction objective. Inspired by Zhu et al. (2020); Cheng et al. (2021), which are end-to-end prediction objectives and successfully address multiple tasks without modifying the architecture, loss, or the training procedure, the merits of Transformer were inherited and CarcassFormer was proposed. Our network is an end-to-end Transformer-based framework and simultaneously tackles both segmentation and classification tasks.

Transformer-based networks have also found application in addressing detection and seg- mentation challenges within poultry science. Lin et al. (2022) proposes a vision transformer model to screen the breeding performance of roosters by analyzing correlations between cockscomb characteristics and semen quality, aiming to overcome the time-consuming and error-prone nature of human-based screening. Hu et al. (2023) improves pig segmentation in farming environments using a grouped transformer attention module with Mask R-CNN networks and data augmentation. Zhao et al. (2023) proposes a real-time mutton multipart classification and detection method using Swin-Transformer. He et al. (2023b) presents Residual-Transformer-Fine-Grained (ResTFG), a model merging transformer and CNN for precise classification of 7 chicken Eimeria species from microscopic images.

MATERIALS AND METHODS

Data Collection

The data was collected at the University of Arkansas pilot processing plant (Fayetteville, AR). Multiple broiler chicken products at different ages were processed using standard commercial practices and following rigorous animal-handling procedures that are in compliance with federal and institutional regulations regarding proper animal care practices FASS (2010). The video-capturing system was set up in the area after feather picking and before chilling and evisceration. We decided on his system placement so that 3 common kinds of defects that can occur during normal processing could be evaluated, namely tearing of the skin, presence of feathers, and broken/disjointed bones.

To obtain the dataset named CarcassDefect, a camera was set up in front of the shackle line, whereas a black curtain was hung behind the shackle. Videos were recorded at 10 frames per second. The camera setup can be visualized in Figures 2 and 3. In the end, a total of 7,321 images were collected, comprising 4,279 single carcass images and 3,042 multiple carcass images. Figure 4 illustrates some images from our CarcassDefect dataset, which comprised a large diversity of carcass quality such as resolution (small carcass, large carcass), the number of carcass per image (a single carcass per image, multiple carcasses per image), various defect (carcass defect can be the one with tearing of skin, feathers, broken/disjointed bones.), etc.

Figure 2.

Camera setup for data collection. A black curtain is hung behind the shackle to provide a certain contrast to the carcasses. A camera is placed to capture the carcasses within the black curtain.

Figure 3.

An overview image of the shooting location. The black curtain is hung on the wall behind the shackle.

Figure 4.

Illustrations of data collected, which comprises (a) single carcass/instance per image/frame; (b) multiple carcass/instance per image/frame; (c)carcass/instance at different scale/resolution. The carcass is processed with various defects such as tearing of skin, feathers, broken/disjointed bones.

Data Annotation

Upon acquiring the video data, the next crucial step is to annotate the images extracted from the footage to generate training data for detection, segmentation, and classification tasks. Annotation involves labeling each frame with bounding boxes for detection, masks for segmentation, and labels for classification. This process enables the computer vision system to learn from the annotated data, which enhances its ability to perform these tasks accurately and efficiently. The data annotation process is illustrated in Figure 5. The annotated data is saved in a JSON file and follow the COCO format Lin et al. (2014) as demonstrated in Figure 6. In this COCO format, the data is described as follows:

• •Categories: defined as “normal” and “defect” presenting labeled in the dataset. The defect class is determined for a carcass that has either “feather” or “broken wings” “broken legs” or “peeled skin.”
• •
  Images: frames extracted from recorded videos. images is a list of objects with meta- data information about the image. An object includes the following keys:

  • –
    id: a unique identifier that differentiates each image within a list. It can be defined as the file name.
  • –
    file_name: the name of the file. In the example (Figure 6).
  • –
    width: the image height such as 950 pixels.
  • –
    height: the image height such as 960 pixels.
  • –
    date_captured: the date and time when the image was captured.
• •
  Annotations: contain all meta-data about the labels related to an object. They are a bounding box, segmentation mask and classification label.

  • –
    id: The index of instance.
  • –
    image_id: The index of the corresponding image. This image_id is corresponding to id in images.
  • –
    category_id: This is category id which is defined in categories. In our case, category_id is either ‘1′ - normal or ‘0′ - defect.
  • –
    iscrowd: if there are multiple instances/carcasses in the image, iscrowd is set as 1. Otherwise, iscrowd is set as 0 if there is a single instance/carcass in the image.
  • –
    area: is the area of instance in the image.
  • –
    bbox: The bounding box determines an object's location represented as [xmin, ymin, width, height] where the (xmin, ymin) coordinates correspond to the top- left position of an object and (width, height) are width and height of the object. In the example shown in Figure 6, xmin = 27, ymin = 0, width = 546, height = 731.
  • –
    segmentation: The segmentation mask is specified by Run-length encoded (RLE) values Golomb (1966).

Figure 5.

An illustration of Data Annotation Process. Each frame from the recorded video is annotated with bounding boxes for detection, masks for segmentation, and defect labels for classification.

Figure 6.

A demonstration of data annotation in JSON file following COCO format.

The data statistic of our CarcassDefect dataset is shown in Tables 1 and 2. Table 1 shows the distribution of the image between a single carcass per image and multiple carcasses per image between 2 categories of normal and defect. Table 2 shows the distribution of the instance between a single carcass per image and multiple carcasses per image between 2 categories of normal and defect.

Table 1.

The distribution of the images in CarcassDefect Dataset in regard to the normal carcass and defective carcass at both a single carcass per frame and multiple carcasses per frame.

	Single carcass per image	Multiple carcasses per image	Total
Trainset	3,017	2,115	5,132
Valset	754	535	1,289
Testset	508	392	900
Total	4,279	3,042	7,321

Table 2.

The distribution of the instances in CarcassDefect Dataset regarded as normal and defective carcasses at both a single carcass per frame and multiple carcasses per frame.

	Single carcass per image		Multiple carcasses per image		Total
	Normal	Defeat	Normal	Defeat
Trainset	1,302	1,715	1,571	1,842	6,430
Valset	355	399	422	466	1,642
Testset	320	188	359	267	1,134
Total	1,977	2,302	2,352	2,575	9,206

Proposed Method

In the sections below, the proposed end-to-end transformer-based framework, termed CarcassFormer, is introduced for chicken carcass detection, segmentation, and carcass defect classification. Figure 1 illustrates the flowchart of our CarcassFormer network consisting of 4 key parts: Backbone, Pixel Decoder, Multi-Scale Transformer Encoder, and Masked- attention Transformer Decoder. To train CarcassFormer, the stochastic gradient descent (SGD) optimizer was utilized with a learning rate of 0.0001 and a batch size of 4 over 100 epochs. The experiments were conducted using an Intel(R) Core(TM) i9-10980XE 3.00GHz CPU and a Quadro RTX 8000 GPU.

Figure 1.

Top: Overall flowchart of our proposed CarcassFormer consisting of 4 components: 1. network backbone; 2. pixel decoder; 3. mask-attention transformer decoder; 4. instance mask class prediction. Bottom: details of third component mask-attention transformer decoder.

Backbone

A backbone network, a foundational architecture employed for feature extraction, is typically pretrained on a variety of tasks and has demonstrated its effectiveness across various domains. AlexNet Krizhevsky et al. (2017) is regarded as the inaugural Deep Learning (DL) backbone. The VGG family, which includes VGG-16 and VGG-19 Simonyan and Zisserman (2014), is one of the most prevalent backbones utilized in computer science endeavors. In contrast to AlexNet and VGG, ResNets He et al. (2016) are based on Convolutional Neural Networks (CNNs) and were developed concomitantly with the introduction of residual networks. ResNet variants, such as ResNet-18, ResNet-34, ResNet-50, ResNet-101, and ResNet-151, are extensively employed for object detection and semantic segmentation tasks. Following the advent of ResNets, numerous other CNN-based backbones have been proposed, including Inception Szegedy et al. (2015), DenseNet Huang et al. (2017), DarkNet Lin et al. (2013), ShuffleNet Zhang et al. (2018), MobileNet Howard et al. (2017), and YOLO Huang et al. (2018). Recently, there has been a significant advancement in back- bone architectures, incorporating transformer architecture Vaswani et al. (2017), along with leveraging the multiscale features of ResNet. Prominent examples of these advancements include ViT Dosovitskiy et al. (2020), PvT Zhao et al. (2017), and Swin Liu et al. (2021). In the present work, ResNet (i.e., ResNet-18, 34, 50) He et al. (2016) and Swin (i.e., Swin-T) are employed as the backbone network.

By utilizing ResNets He et al. (2016) as the backbone network, an input image $I$ with dimensions $H\times W$ is transformed into a multiscale feature $F$, specifically a set of 4 feature maps. These feature maps are represented as $F_1\in {\mathbb{R}}^{C_{F_1}\times \frac{H}{4}\times \frac{W}{4}},F_2\in {\mathbb{R}}^{C_{F_2}\times \frac{H}{8}\times \frac{W}{8}},F_3\in {\mathbb{R}}^{C_{F_3}\times \frac{H}{16}\times \frac{W}{16}},F_4\in {\mathbb{R}}^{C_{F_4}\times \frac{H}{32}\times \frac{W}{32}}$, where $C_{F_1},C_{F_2},C_{F_3},C_{F_4}$ denote the number of channels.

Pixel Decoder

This module enhances the multi-scale features of an image by utilizing 4 feature maps from the backbone. It consists of 2 parts: the multi-scale transformer encoder and the per-pixel embeddings module. In general, the multi-scale transformer encoder uses an attention mechanism to learn the correlation between the multi-scale feature maps $F_1,F_2,F_3,F_4$. This results in corresponding, richer encoded feature maps $D_1,D_2,D_3,D_4$. Meanwhile, the per-pixel embeddings module takes the encoded feature map $D_1$ to compute the per-pixel embeddings ${ℇ}_{pixel}$ of the image.

Multi Scale Transformer Encoder

This module takes the last 3 features from the backbone, ordered from low to high resolution (i.e., $F_4,F_3,F_2,F_1$), are processed in a hierarchical fashion. These 3 features first go through an embedding projection $f_E$ to achieve the flattened embed feature $S_i$ with a consistent channel size $C_e$. Note that the value of $C_e$ is equal to $C_{F_1}$, and this is specifically intended for computing the per-pixel embeddings in section per-pixel embeddings module.

$$S_i=f_E\left(F_i\right)$$ (1)

Where $i=\left\{4,3,2,1\right\}$, $S_i\in {\mathbb{R}}^{H_i\times W_i\times C_e},$ $f_E$ is a $1\times 1$ convolution layer with the output dimension of $C_e$, followed by a flatten layer. The purpose of the flatten layer is to prepare $S_i$ as input for a transformer layer, which requires a sequence of embedding features rather than spatial features.

To investigate the correlated feature embeddings between different levels, the flattened embedding features $S_i$ from each multi-scale level were concatenated and passed through a transformer encoder. This involves merging the flattened embeddings from different levels into a single input sequence for the transformer encoder.

$$S={\left[S_i\right]}_{i\in \left\{4,3,2,1\right\}}$$ (2)

where $S\in {\mathbb{R}}^{K\times C_e}$^, K is the total number of embedding features.

However, since the current embedding features $S$ are flattened out of their original spatial shapes and concatenated from multiple levels, they do not include information about the spatial location and scale level of each feature. To address this issue, each embedding feature in $S$ is supplemented with 2 types of learnable encoding. The first is a positional encoding that provides spatial information about the original location of each feature within the image. The second is a level encoding that enables the transformer encoder to distinguish between features from different scales. By incorporating these encodings, spatial and scale level information is preserved during the calculation process. Let denote the learnable positional encodings as $P$ and the learnable level encodings as $L$, where $P$ and $L$ share the same shape with $S,P,L\in {\mathbb{R}}^{K\times C_e}$.

Let denote the multi scale transformer encoder as $f_G$, this transformer follows the architecture designed in Dosovitskiy et al. (2020). This transformer encoder produces learned features from the input sequence. It takes a sequence of embedded features and outputs encoded features that capture the relationships between the elements. These encoded features retain important information while removing redundancy. The encoder computes each encoded feature using a self-attention mechanism Vaswani et al. (2017), allowing it to selectively focus on the most relevant features and capture long-range dependencies, making it effective for enriching multiscale features. Formulary, the correlated feature embeddings between different level $E\in {\mathbb{R}}^{K\times C_e}$ is computed by passing $S,L$and $P$ through $f_G$.

$$E=f_G\left(S,P,L\right)$$ (3)

The correlated feature embedding E is divided into groups based on the multi-scale level, denoted as $E_i$ where $i\in \left\{4,3,2,1\right\}$and $E_i\in {\mathbb{R}}^{H_i\times W_i\times C_e}$. Next, each $E_i$ is restored to its original spatial shape by unflattening, resulting in an output enriched multi-scale feature map $D_i$.

$$D_i=unflatten\left(E_i\right)$$ (4)

where $D_i\in {\mathbb{R}}^{C_e\times H_i\times W_i}$.

In summary, this module takes the multiscale feature map $F_4,F_3,F_2,F_1$ and outputs the enriched multi-scale feature map $D_1,D_2,D_3,D_4$, which captures the correlation and important information while removing redundancy.

Perpixel Embeddings Module

This section describes the second stage of Pixel Decoder, where the perpixel embedding

${ℇ}_{pixel}$ is computed. This module takes the encoded feature map $D_1$ from the Multi Scale Transformer Encoder module as input. The perpixel embedding ${ℇ}_{pixel}$ is computed as follow:

$${ℇ}_{pixel}=f_U\left(D_1\right)$$ (5)

The function $f_U$ is a sequence of two $2\times 2$ transposed convolutional layers with stride 2, which scales up the spatial shape of $D_1$ 4 times to the original image's spatial shape.

As a result, ${ℇ}_{pixel}$ has a dimension of ${\mathbb{R}}^{C_e\times H\times W}.$ Intuitively, each pixel feature of ${ℇ}_{pixel}$ represents both the semantic and the mask classification feature of the corresponding pixel on the original image.

Mask-Attention Transformer Decoder

Mask Predictor

To predict the segmented masks of possible instances in an image, perpixel embeddings ${ℇ}_{pixel}$ were utilized. These embeddings represent both the semantic and mask classification features of each corresponding pixel on the original image.

Then, the prediction process involves learning $N$ per-segment query embeddings $Q\in {\mathbb{R}}^{N\times C_e}$, which represent the features of the maximum $N$ possible instances in the image. Each instance query embedding correlates with every single pixel feature in ${ℇ}_{pixel}$ to determine whether the pixel belongs to the corresponding instance or not. Therefore, the predicted instance segmentation mask was derived as follows:

$$M=f_P\left(Q,{ℇ}_{pixel}\right)$$ (6)

where $M\in {\mathbb{R}}^{N\times H\times W}$, which are $N$ masks of $N$ possible instances in the image. The Mask Predictor $f_P$ is a simple dot product on the feature channel $C_e$, followed by a sigmoid activation.

Mask-Attention Transformer Decoder

The Mask-Attention Transformer Decoder $f_T$ was employed to obtain effective per- segment query embeddings $Q\in {\mathbb{R}}^{N\times C_e}$ that represented instances in the image. This de- coder applies attention to the image features, allowing it to decode the per-segment query embeddings and capture the instance mask feature.

The third blob in our overall flowchart (Figure 1) illustrates the procedure on applying the Mask-Attention Transformer Decoder. In general, this module decodes $N$ per-segment query embeddings $Q\in {\mathbb{R}}^{N\times C_q}$ from the encoded feature maps $D_1,D_2,D_3,D_4$. These query embeddings represent the features of the maximum $N$ possible instances in the image. The decoding procedure is performed recurrently, with each step treated as a layer (denoted as $l$) and beginning at $l=0$. The encoded feature maps $D$ have 4 levels, denoted as $D_1,D_2,D_3,D_4$. Therefore, this recurrent process occurs 4 times, progressing from the lowest to highest resolution encoded feature maps. During each recurrent step, the encoded feature maps that are considered are $D_{4-l}$, where $l$ represents the current layer. This means that during the first recurrent step $\left(l=0\right)$, the encoded feature maps that are used are $D_4$. During the second recurrent step $\left(l=1\right)$, the encoded feature maps that are used are $D_3$. During the third recurrent step $\left(l=2\right)$, the encoded feature maps that are used are $D_2$. Finally, during the fourth recurrent step $\left(l=3\right)$, the encoded feature maps that are used are $D_1$. At each layer, the queries $Q_{l+1}$ are decoded from the previous layer's query $Q_{l+1}$ and the corresponding encoded feature maps.

Additionally, a predicted mask, $M_l$ is computed by using the current query embeddings $Q_l$ and the per-pixel embeddings ${ℇ}_{pixel}$. The resulting mask is then interpolated to the same size as the current feature map $D_{4-l}$. This mask is used as an attention mechanism that helps the query embeddings to focus on the most salient parts of the feature maps. Specifically, during the decoding process, the attention mask is applied to the encoded feature maps $D_{4-l}$, allowing the query embeddings to selectively attend to certain regions of the feature maps that are most relevant to the instance being decoded. Formulary, at each recurrent step:

$$M_l=f_P\left(Q_l,\text{AptCommand}2107{;}_{pixel}\right)$$

$$Q_{l+1}=f_T\left(Q_l,D_{4-l},M_l\right)$$ (7)

Instance Mask and Class Prediction

The procedure can be visualized using the fourth component of the overall flowchart, as shown in Figure 1. In this step, the query encoder $Q_L$ (where $L=3$) and the perpixel embeddings $\text{AptCommand}2107{;}_{pixel}$ are utilized to compute the output instance segmentation masks, denoted as $M_{final}$. These masks, represented by a tensor $M_{final}$, correspond to N possible instances within the image.

To generate the masks, the function $f_P$ takes $Q_L$ and $\text{AptCommand}2107{;}_{pixel}$ as inputs:

$$M_{final}=f_P\left(Q_L,\text{AptCommand}2107{;}_{pixel}\right)$$ (8)

Moreover, alongside the masks, the semantic class of each instance is predicted using another function called $f_C$. This function is implemented as a Multi-Layer Perceptron (MLP) with 2 hidden layers. It takes the per-segment embeddings $Q_L$ as input and produces $N$ semantic classes, represented by $C_{final}\in {\mathbb{R}}^{N\times C}$. Here, $C$ represents the number of semantic categories.

The prediction of semantic classes can be expressed as:

$$C_{final}=f_C\left(Q_L\right)$$ (9)

By combining these steps, this module is able to generate both instance segmentation masks ($M_{final}$) and predict the semantic class labels for each instance ($C_{final}$) using the decoded instance queries ($Q_L$) and per-pixel embeddings ($\text{AptCommand}2107{;}_{pixel}$).

Metrics

We adopt Average Precision (AP) to evaluate the method. AP quantifies how well the model is able to precisely locate and classify objects (e.g., defect or normal) within an image. The AP computation from MSCOCO Lin et al. (2014) was followed.

In the recognition task, each image is associated with a single prediction for classification. Evaluating the model became straightforward as the accuracy metric could be calculated, measuring the ratio of correct predictions. On the other hand, in the field of object detection and classification, a prediction comprises a bounding box or a segmentation mask that helps locate the object, along with the predicted category for that object. To determine a correct prediction, 2 criteria are considered. Firstly, the prediction must have an Intersection over Union (IoU) value greater than a threshold ϵ when compared to the actual box or mask of the object. Secondly, the prediction must accurately classify the category of the object. In addition, for each image, a method can output multiple predictions and the number of predictions can be higher or lower than the actual object within the image. Thus, precision and recall metrics are taken into account. Precision (Pre) is the ratio of correct predictions to the total number of predictions. Precision can be considered as a measure of how precise the model's predictions were in terms of correctly detecting objects. Meanwhile, recall (Rec) is the ratio of correct predictions to the total number of actual objects within the image. It can be thought of as a measure of how comprehensive the model's predictions are in terms of capturing all the objects present.

Specifically, AP is computed at different IoU thresholds $ϵ$, which determine what is considered a correct prediction. For instance, when the threshold $ϵ$ is set to 50%, it is denoted as AP@50. Let's consider an image with a list of actual ground truth objects denoted as $A=\left\{a_1,a_2,...,a_n\right\}$, and a method that generates $m$ predictions denoted as $B=\left\{b_1,b_2,...,b_m\right\}$. The predictions are sorted in descending order based on their confidence scores. In the process, the sorted list $B$ was iterated through, and at each step, the correctness of the prediction $b_i$ (where $i\in \left\{1,2,...,m\right\}$) was determined. This is done by checking if the category is correctly matched and if the IoU is greater than the specified threshold ϵ. The number of correct predictions at this step was kept track of, denoted as $C_i$. Using $C_i,$ the precision $Pr{e}_i$ and recall $Re{c}_i$ could be computed at each step. The iteration stops at $Re{c}_i=1$, indicating that all the objects have been captured, or when all the predictions were iterated through. The $AP@ϵ$is then computed as follows:

$$AP@ϵ=\underset{0}{\overset{1}{\int }}Pre\left(Rec\right),dRec$$ (10)

The reported AP in our table is the average of AP values ranging from $AP@50$ to $AP@95$, with a step size of 5% as depicted in Equation 13. This provides a comprehensive evaluation of the model's performance across different IoU thresholds and recall levels.

$$AP=\frac{1}{10}\sum _{ϵ=0.5;ϵ+=0.05}^{0.95}AP@ϵ$$ (11)

We also quantify the model's complexity using 3 key metrics: the number of floating- point operations (FLOPs), the count of model parameters (Params), and the frames processed per second (FPS). FLOPs are computed as an average over 100 testing images. FPS is evaluated on a Quadro RTX 8,000 GPU with a batch size of 1, calculated as the average runtime across the entire validation set, inclusive of postprocessing time.

RESULTS AND DISCUSSION

Implementation Details

The implementation of the pixel decoder in this study involves the use of an advanced multiscale deformable attention Transformer (DERT) as described in Zhu et al. (2020). Specifically, the DERT is applied to feature maps with resolutions of 1/8, 1/16, and 1/32. A simple upsampling layer with a lateral connection is then employed on the final 1/8 feature map to generate the perpixel embedding feature map of resolution 1/4. The Transformer encoder used in this study is configured with L=3 and a set of 100 queries.

Quantitative Performance and Comparison

In this section, our proposed CarcassFormer was evaluated on the Carcass dataset (section data seletion), which consisted of 2 subsets corresponding to a single carcass per image and multiple carcasses per image. The performance of CarcassFormer on various metrics, as shown in Table 3 and Table 3 for different tasks, was detailed reported. The authors then compared CarcassFormer with both CNN-based networks, namely Mask R-CNN He et al. (2017) and HTC Chen et al. (2019), as well as Transformer-based networks, namely Mask DINO Li et al. (2023), Mask2Former Cheng et al. (2022) and QueryInst Fang et al. (2021). The comparison was conducted using 3 different backbone networks: ResNet-34, ResNet-50, and Swin-T. The performance for 2 subsets was reported: a single carcass per image (Table 5, Table 6) and multiple carcasses per image (Tables 7,8, and 9). For each table, the metrics for detection, classification, segmentation, and model complexity were reported, as defined in section metrics.

Table 3.

Detailed performance of CarcassFormer on single carcass per image dataset on both detection and segmentation, whereas AP_normal & AP_defect include classification results.

Backbone	Task	AP	AP50	AP75	AP95	APnormal	APdefect	Params	FLOPs	FPS
ResNet 34	Detection	97.70	98.23	98.23	92.89	98.02	97.38	41M	274G	5.1
	Segmentation	99.22	99.22	99.22	99.22	100.00	98.45
ResNet 50	Detection	95.18	95.18	95.18	95.18	94.02	96.34	41M	274G	5.1
	Segmentation	98.43	98.43	98.43	98.43	99.79	97.06
Swin-T	Detection	95.69	95.79	95.93	95.32	94.23	97.15	46M	281G	4.5
	Segmentation	97.77	98.65	98.93	98.15	99.11	96.42

Table 5.

Performance comparison between CarcassFormer with both CNN-based networks, namely mask R-CNN He et al. (2017) and HTC Chen et al. (2019) and transformer-based networks, namely Mask2Former Cheng et al. (2022) and QueryInst Fang et al. (2021) on both detection, classification and segmentation tasks. The comparison is conducted on ResNet-34 backbone network and in the case of single carcass per image.

Net.	Method	Venue	Detection and classification			Segmentation			Model complexity
			AP	APnormal	APdefect	AP	APnormal	APdefect	Params	FLOPs	FPS
CNN-based	Mask R-CNN He et al. (2017)	2017	79.73	87.82	71.65	81.36	85.41	77.31	41M	204G	5.8
	HTC Chen et al. (2019)	2019	89.00	95.30	82.60	82.30	86.30	78.40	109M	290G	4.3
Transformer-based	QueryInst Fang et al. (2021)	2021	90.40	98.00	82.90	82.20	88.10	76.30	45M	279G	4.8
	Mask2Former Cheng et al. (2022)	2022	58.33	58.42	58.24	75.32	92.08	58.57	41M	272G	5.2
	Mask DINO Li et al. (2023)	2023	88.12	95.11	81.12	77.67	83.45	71.89	49M	278G	5.1
	CarcassFormer (Ours)		97.70	98.02	97.38	99.22	100.00	98.45	41M	274G	5.1

Net. denotes Network architecture.

Table 6.

Performance comparison between CarcassFormer with both CNN-based networks, namely mask R-CNN He et al. (2017) and HTC Chen et al. (2019) and transformer-based networks, namely Mask2Former Cheng et al. (2022) and QueryInst Fang et al. (2021) on both Detection, Classification and Segmentation tasks. The comparison is conducted on ResNet-50 backbone network and in the case of single carcass per image.

			Detection and classification			Segmentation			Model complexity
Net.	Method	Venue	AP	APnormal	APdefect	AP	APnorma	APdefect	Params	FLOPs	FPS
CNN-based	Mask R-CNN He et al. (2017)	2017	80.35	90.15	70.56	84.19	88.39	80.00	44M	207G	5.3
	HTC Chen et al. (2019)	2019	88.10	96.20	80.00	84.30	89.00	79.70	112M	294G	3.9
Transformer-based	QueryInst Fang et al. (2021)	2021	64.60	75.50	53.60	72.70	78.60	66.70	48M	281G	4.4
	Mask2Former Cheng et al. (2022)	2022	85.05	91.23	78.87	85.11	91.23	78.99	44M	276G	4.8
	Mask DINO Li et al. (2023)	2023	85.12	91.44	79.10	86.13	92.11	80.15	52M	280G	4.6
	CarcassFormer (Ours)		95.18	94.02	96.34	98.43	99.79	97.06	44M	278G	4.6

Net. denotes Network architecture. The best score in each table is highlighted in bold.

Table 7.

Performance comparison between CarcassFormer with both CNN-based networks, namely Mask R-CNN He et al. (2017) and HTC Chen et al. (2019) and Transformer-based networks, namely Mask2Former Cheng et al. (2022) and QueryInst Fang et al. (2021) on both Detection, Classification and Segmentation tasks. The comparison is conducted on ResNet-34 backbone network and in the case of multiple car- casses per image.

Net.	Method	Venue	Detection and classification			Segmentation			Model complexity
			AP	APnorma	APdefect	AP	APnormal	APdefect	Params	FLOPs	FPS
CNN-based	Mask R-CNN He et al. (2017)	2017	77.08	84.33	69.83	74.81	79.00	70.63	41M	204G	5.8
	HTC Chen et al. (2019)	2019	77.80	89.70	65.90	74.00	79.10	68.90	109M	290G	4.3
Transformer-based	QueryInst Fang et al. (2021)	2021	84.10	89.60	78.70	83.20	87.70	78.70	45M	279G	4.8
	Mask2Former Cheng et al. (2022)	2022	53.86	54.00	53.72	71.69	85.39	58.00	41M	272G	5.2
	Mask DINO Li et al. (2023)	2023	68.44	74.55	62.33	78.80	88.26	69.33	49M	278G	5.1
	CarcassFormer (Ours)		89.72	93.48	85.96	98.23	98.77	97.68	41M	274G	5.1

Net. denotes Network architecture. The best score in each table is highlighted in bold.

Table 8.

Performance comparison between CarcassFormer with both CNN-based networks, namely mask R-CNN He et al. (2017) and HTC Chen et al. (2019) and Transformer-based networks, namely Mask2Former Cheng et al. (2022) and QueryInst Fang et al. (2021) on both Detection, Classification and Segmentation tasks. The comparison is conducted on ResNet-50 backbone network and in the case of multiple car- casses per image.

Net.	Method	Venue	Detection and classification			Segmentation			Model complexity
			AP	APnorma	APdefect	AP	APnormal	APdefect	Params	FLOPs	FPS
CNN-based	Mask R-CNN He et al. (2017)	2017	78.76	85.61	75.73	80.67	85.61	75.73	44M	207G	5.3
	HTC Chen et al. (2019)	2019	77.40	83.50	71.40	74.90	77.70	72.10	112M	294G	3.9
Transformer-based	QueryInst Fang et al. (2021)	2021	60.90	67.70	54.00	60.40	66.90	54.00	48M	281G	4.4
	Mask2Former Cheng et al. (2022)	2022	73.35	88.03	58.66	75.54	90.93	60.15	44M	276G	4.8
	Mask DINO Li et al. (2023)	2023	76.22	84.11	68.33	79.93	92.12	67.74	52M	280G	4.6
	CarcassFormer (Ours)		90.45	93.42	87.49	98.96	99.15	98.76	44M	278G	4.6

Net. denotes Network architecture. The best score in each table is highlighted in bold.

Table 9.

Performance comparison between CarcassFormer with Mask2Former Cheng et al. (2022) on both Detection, Classification and Segmentation tasks. The comparison is conducted on Swin-T backbone network and in the case of multiple carcasses per image.

		Detection and classification			Segmentation			Model complexity
Method	Venue	AP	APnormal	APdefect	AP	APnormal	APdefect	Params	FLOPs	FPS
Mask R-CNN He et al. (2016)	2017	78.82	86.12	71.52	81.22	87.12	75.32	46M	230G	4.8
Mask2Former Cheng et al. (2022)	2022	73.10	88.14	58.05	77.68	92.89	62.47	46M	280G	4.6
CarcassFormer (Ours)		89.34	94.18	84.50	98.70	99.47	97.92	46M	281G	4.5

Net. denotes Network architecture. The best score in each table is highlighted in bold.

Detailed Quantitative Performance

Detailed performance conducted by our CarcassFormer is reported in Table 3, Table 4 corresponding to 2 subsets: a single carcass per image and multiple carcasses per image. In each subset, our CarcassFormer network was examined on 3 different backbone networks: ResNet-34, ResNet-50, and Swin-T. For both tasks of detection and segmentation, Average Precision (AP) at different metrics of AP@50, AP@75, AP@95, and AP[50:95] (referred to as AP) were reported. Regarding detection and classification, AP_normal and AP_defect were evaluated for normal and defect classes. The results obtained from 2 tables (Table 3, Table 4) underscores the remarkable performance of our model across various backbones and tasks, with every configuration achieving an AP of over 85 for all metrics. Additionally, it becomes evident that the Multiple Carcasses Per Image Dataset presents greater challenges compared to the Single Carcasses Per Image Dataset. This observation is substantiated by a noticeable decline in performance metrics when handling multiple overlapping carcasses per image, as opposed to the single carcass per image scenario.

Table 4.

Detailed performance of CarcassFormer on multiple carcasses per image dataset on both detection and segmentation, whereas AP_normal & AP_defect include classification results.

Backbone	Task	AP	AP50	AP75	AP95	APnormal	APdefect	Params	FLOPs	FPS
ResNet 34	Detection	89.72	91.45	91.45	78.51	93.48	85.96	41M	274G	5.1
	Segmentation	98.23	99.34	98.86	92.55	98.77	97.68
ResNet 50	Detection	90.45	91.55	91.55	83.41	93.42	87.49	41M	274G	5.1
	Segmentation	98.96	99.98	99.48	94.36	99.15	98.76
Swin-T	Detection	89.34	91.27	91.73	79.11	94.18	84.50	46M	281G	4.5
	Segmentation	98.70	99.29	98.32	93.10	99.47	97.92

Single Carcass Per Image

Table 5, Table 6 present the performance on a single carcass per image using ResNet- 34 and ResNet-50, respectively.

Table 5 compares the performance of CarcassFormer with existing methods on ResNet-34. In the first group, HTC Chen et al. (2019) obtains better performance than Mask R-CNN He et al. (2017) whereas our CarcassFormer gains significant performance gaps compared to both HTC Chen et al. (2019) and Mask R-CNN He et al. (2017). Take HTC Chen et al. (2019) as an example, CarcassFormer outperforms HTC with 8.70% higher AP for detec- tion, 2.72% higher AP for normal carcass classification, 14.78% higher AP for defect carcass classification, 16.92% higher AP for segmentation, 13.70% higher AP segmentation for nor- mal carcass and 20.05% higher AP segmentation for defect carcass. In the second group, QueryInst Fang et al. (2021) obtains better performance than Mask2Former Cheng et al. (2022) and Mask DINO Li et al. (2023) while our CarcassFormer obtains the best performance. Compared to QueryInst Fang et al. (2021), CarcassFormer gains 7.30% higher AP for detection, 0.02% higher AP for normal carcass classification 14.48% higher AP for defect carcass classification, 17.02% higher AP for segmentation, 11.90% higher AP segmentation for normal carcass, 22.15% higher AP segmentation for defect carcass.

Table 6 compares the performance of CarcassFormer with existing methods on ResNet-50.

In the first group, HTC Chen et al. (2019) outperforms Mask R-CNN He et al. (2017) whereas CarcassFormer outperforms HTC Chen et al. (2019) with significant performance gaps, including 7.08% higher AP for detection, 16.34% higher AP for defect carcass classification, 14.13% higher AP for segmentation, 10.79% higher AP segmentation for normal carcass and 17.36% higher AP segmentation for defect carcass while it is compatible with HTC Chen et al. (2019) on normal classification. In the second group, while Mask2Former Cheng et al. (2022) and Mask DINO Li et al. (2023) obtains much better performance than QueryInst Fang et al. (2021), our CarcassFormer outperforms MaskDINO Li et al. (2023) 10.06% higher AP for detection, 2.58% higher AP for normal carcass classification, 17.24% higher AP for defect carcass classification, 13.30% higher AP for segmentation, 7.68% higher AP segmentation for normal carcass, 16.91% higher AP segmentation for defect carcass.

Multiple Carcasses Per Image

Table 7, Table 8 present the performance on multiple carcasses per image using ResNet-34 and ResNet-50, respectively.

Table 7 compares the performance of CarcassFormer with existing methods on ResNet-34. In the first group, while Mask R-CNN He et al. (2017) and HTC Chen et al. (2019) are quite compatible on all tasks, our CarcassFormer gains big performance gaps. Take HTC Chen et al. (2019) as an example, CarcassFormer achieves 11.92% higher AP for detection, 3.78% higher AP for normal carcass classification, 20.06% higher AP for defect carcass classification, 24.23% higher AP for segmentation, 19.67% higher AP segmentation for normal carcass, 28.79% higher AP segmentation for defect carcass. In the second group, while QueryInst Fang et al. (2021) outperforms Mask2Former Cheng et al. (2022) and Mask DINO Li et al. (2023), our CarcassFormer obtains better performance than QueryInst Fang et al. (2021) with notable gaps, that is, 5.62% higher AP for detection, 3.88% higher AP for normal carcass classification, 7.26% higher AP for defect carcass classification, 15.03% higher AP for segmentation, 11.07% higher AP segmentation for normal carcass, 18.98% higher AP segmentation for defect carcass.

Table 8 compares the performance of CarcassFormer with existing methods on ResNet-50. In the first group, while Mask R-CNN He et al. (2017) outperforms HTC Chen et al. (2019), our CarcassFormer achieves a best performance with 11.69% higher AP for detection, 7.81% higher AP for normal carcass classification, 11.76% higher AP for defect carcass classification, 18.29% higher AP for segmentation, 13.54% higher AP segmentation for normal carcass, 23.03% higher AP segmentation for defect carcass compared to Mask R-CNN He et al. (2017). In the second group, while Mask2Former Cheng et al. (2022) Mask DINO Li et al. (2023) obtain better performance than QueryInst Fang et al. (2021), our CarcassFormer achieves the best performance. It gains 14.23% higher AP for detection, 9.31% higher AP for normal carcass classification, 19.16% higher AP for defect carcass classification, 19.03% higher AP for segmentation, 7.03% higher AP segmentation for normal carcass, 31.02% higher AP segmentation for defect carcass compared to the second best method Mask DINO Li et al. (2023).

Table 9 compares the performance of CarcassFormer with Mask2Former Cheng et al. (2022) and Mask R-CNN He et al. (2017) on Swin-T. In comparison to the CNN-based method, Mask R-CNN He et al. (2017), our approach yields significant improvements across various performance metrics. Specifically, we observe a 10.52% increase in average precision (AP) for detection, an 8.06% enhancement for normal carcass classification, a 12.98% boost for defect carcass classification, a remarkable 17.48% rise for segmentation, as well as notable gains of 12.35% and 22.6% in AP segmentation for normal and defect carcasses, respectively. In terms of comparison with transformer-based network, namely Mask2Former, our CarcassFormer achieves the significant better performance than both Mask2Former and Mask R-CNN. Indeed, it gains 16.24% higher AP for detection, 6.04% higher AP for nor- mal carcass classification, 26.45% higher AP for defect carcass classification, 21.02% higher AP for segmentation, 6.58% higher AP segmentation for normal carcass, 35.45% higher AP segmentation for defect carcass.

Model Complexity. Analysis of model complexity reveals that our method exhibits comparable complexity to the majority of existing methods. However, it consistently delivers notable performance enhancements across diverse tasks. Specifically, in the case of ResNet- 34, as illustrated in Table 5, Table 7, our model has the smallest number of model parameters, equivalent to that of Mask R-CNN He et al. (2017) and Mask2Former Cheng et al. (2022), while maintaining comparable FLOPs and FPS with these models. However, our model exhibits a significant performance advantage over both. This trend is similarly observed for ResNet-50, as shown in Table 6, Table 8, and for Swin-T, as depicted in Table 9, where our model demonstrates comparable model complexity but yields substantial performance gains compared to other methods.

Qualitative Performance and Comparison

Based on the quantitative comparison in section quantitative performance and comparison, Mask R-CNN He et al. (2017) was selected from the first group, and Mask2Former Cheng et al. (2022) was chosen from the second group to conduct the qualitative comparison. Specifically, the qualitative comparison was reported on both the detection and segmentation tasks, with a greater emphasis on the case of defect, namely feather and skin tearing.

Single Carcass Per Image

Figure 7 presents a qualitative performance comparison among 3 models: Mask R- CNN (a), Mask2Former (b), and our proposed CarcassFormer (c) on the defect of single carcass with feathers is present. While Mask R-CNN can segment the global content well, it fails to segment the details, such as feathers. On the other hand, Mask2Former performs better than Mask R-CNN in capturing details, but it still faces difficulties in capturing fine details, which can be seen at high resolution. Moreover, Mask R-CNN and Mask2Former exhibited a tendency to under-localize the carcass, as observed from the detected bounding box that did not encompass the entire carcass with details on the boundary, such as wings and feathers. In contrast, our CarcassFormer not only accurately localizes the carcass with a fitting bounding box but is also capable of segmenting details at high resolution.

Figure 7.

Performance comparison (A) Mask R-CNN He et al. (2016), (B) Mask2Former Cheng et al. (2022) and (C) our CarcassFormer on the defect where single carcass with feathers. In the Segmentation column, notable parts with feathers were highlighted. Compare with Mask R-CNN and Mask2Former, our CarcassFormer can localize carcass with more accurate bounding box and segment carcass with more details on feathers.

Figure 8 depicts a qualitative performance comparison among 3 models: Mask R-CNN (a), Mask2Former (b), and our proposed CarcassFormer (c), on single carcass with both 2 defects of feather and skin tearing. Although Mask2Former performs better than Mask R-CNN in localizing the carcass with skin tearing, it still faces difficulties in localizing all details on feathers. Conversely, our CarcassFormer accurately localizes the carcass with a fitting bounding box and is also capable of segmenting details at high resolution.

Figure 8.

Performance comparison (A) Mask R-CNN He et al. (2016), (B) Mask2Former Cheng et al. (2022) and (C) our CarcassFormer on 2 defects where single carcass with skins tearing on the back and feathers. In the Segmentation column, notable parts with feathers and skins tearing occurred were highlighted. Compared with Mask R-CNN and Mask2Former, our CarcassFormer desnt not only detect the feathers well but also accurately localize carcass with its all skins tearing.

Multiple Carcasses Per Image

In this section, the qualitative performance on images with multiple carcasses and their overlap was reported. Figure 9 illustrates the qualitative performance of 3 models: Mask R-CNN (a), Mask2Former (b), and our proposed CarcassFormer (c) on multiple, overlapping carcasses with feathers. Both Mask R-CNN and Mask2Former struggle to accurately segment and localize each individual carcass, especially in cases where the feathers of different carcasses overlap. Mask R-CNN lacks detail in the segmentation results, while Mask2Former, despite performing better in localizing individual carcasses, still fails to capture all the details accurately. On the contrary, our CarcassFormer excels at accurately segmenting each individual carcass and capturing the details of feathers, even in complex scenarios of overlap. In Figure 10, the qualitative performance comparison of the 3 models on multiple, overlapping carcasses with both feathers and skin tearing presented. Here, it is evident that Mask R-CNN and Mask2Former both face significant challenges in accurately localizing individual carcasses and providing detailed segmentation, especially for tiny objects like feathers and areas of skin tearing. In stark contrast, our CarcassFormer performs outstandingly in these complex situations. It not only accurately localizes each carcass but also segments the fine details of feathers and skin tearing areas, thereby providing a comprehensive and detailed segmentation output.

Figure 9.

Performance comparison between Mask R-CNN (A) He et al. (2016) Mask2Former Cheng et al. (2022) (B) and our CarcassFormer (C) on overlapping carcasses with feathers. In the Segmentation column, notable parts with feathers were highlighted. Mask R-CNN not only lacks details in the segmentation results but also fails to localize individual carcasses. Although Mask2Former performs better than Mask R-CNN in localizing individual carcasses, it still struggles to accurately segment all details. In contrast, our CarcassFormer can simultaneously segment carcasses with details and accurately localize individual carcasses.

Figure 10.

Performance comparison between (A) Mask R-CNN He et al. (2016), (B) Mask2Former Cheng et al. (2022) and (C): our CarcassFormer on overlapping carcasses with feathers and skins tearing. Segmentation highlights some notable parts with feathers occur. Both Mask R-CNN and Mask2Former struggle with accurately localizing individual carcasses and providing detailed segmentation, especially for fine details like feathers. In contrast, our CarcassFormer excels in simultaneously segmenting carcasses with fine details and accurately localizing individual carcasses.

CONCLUSIONS

In conclusion, an end-to-end Transformer-based network for checking carcass quality, CarcassFormer, has been described. Our CarcassFormer is designed with 4 different components: Network Backbone to extract visual features, Pixel Decoder to utilize feature maps from various scales, Mask-Attention Transformer Decoder to predict the segmented masks of all possible instances, and Instance Mask and Class Prediction to provide segmentation mask and corresponding label of an individual instance. To benchmark the proposed CarcassFormer network, a valuable realistic dataset was conducted at a poultry processing plant. The dataset acquired contained various defects including feathers, broken/disjointed bones, skins tearing, on different settings of a single carcass per image and multiple carcasses per image, and the carcass at various ages and sizes. The CarcassFormer was evaluated and compared with both CNN-based networks, namely Mask R-CNN He et al. (2017) and HTC Chen et al. (2019), as well as Transformer-based networks, namely Mask2Former Cheng et al. (2022) and QueryInst Fang et al. (2021), on both detection, classification, and segmentation tasks using 2 different backbone networks, ResNet-34 and ResNet-50. The extensive qualitative and quantitative experiment showed that our CarcassFormer outperforms the existing methods with remarkable gaps on various metrics of AP, AP@50, AP@75.

Our current CarcassFormer system operates solely on image-based inputs, limiting our ability to track carcasses across frames. While our model can currently determine whether a carcass is defective or not, it lacks the capability to identify specific types of defects, such as feathers around the carcass, feathers on the skin, flesh abnormalities, or broken wings. In our future endeavors, we aim to expand our research to include video analysis, enabling us to track carcasses across frames and thereby enhance the scalability of our system to process a larger volume of carcasses. Additionally, we intend to implement finer-grained defect detection to precisely identify the nature of defects present. This enhancement will provide more detailed insights into the types of defects observed, facilitating improved diagnosis and statistical analysis.

• •Dataset: A poultry carcass dataset was acquired, comprising a total of 7,321 images gathered from real-world environments and collected from diverse chicken ages, chicken size, and number of chickens per frame. The dataset has been carefully annotated by 3 experts.
• •Methodology: CarcassFormer, an effective end-to-end Transformer-based frame- work, was proposed for simultaneously localizing poultry carcass regions, segmenting carcass areas, and determining carcasses with imperfections. CarcassFormer is based on Transformer-based Unet architecture.

  Our CarcassFormer is designed with 4 different components: Network Backbone to extract visual features, Pixel Decoder to utilize feature maps from various scales, Mask- Attention Transformer Decoder to predict the segmented masks of all instances, and Instance Mask and Class Prediction to provide segmentation mask and corresponding label of an individual instance. The extensive experiments showed that Carcass- Former outperforms both CNN-based networks, namely Mask R-CNN He et al. (2017) and HTC Chen et al. (2019), and Transformer-based networks, namely Mask2Former Cheng et al. (2022) and QueryInst Fang et al. (2021) on different backbone networks of ResNet-34 and ResNet-50 on various metrics of AP, AP@50, AP@75.

• •Pretrained models and Code: The pre-trained model and source code of Car- cassFormer is available for research purposes at: https://github.com/UARK-AICV/ CarcassFormer.

DISCLOSURES

The authors declare the following financial interests/personal relationships which may be considered as potential competing interests: uark.edu; cobbvantress.com