FE-P Net: An Image-Enhanced Parallel Density Estimation Network for Meat Duck Counting

Abstract

Traditional object detection methods for meat duck counting suffer from high manual costs, low image quality, and varying object sizes. To address these issues, this paper proposes FE-P Net, an image enhancement-based parallel density estimation network that integrates CNNs with Transformer models. FE-P Net employs a Laplacian pyramid to extract multi-scale features, effectively reducing the impact of low-resolution images on detection accuracy. Its parallel architecture combines convolutional operations with attention mechanisms, enabling the model to capture both global semantics and local details, thus enhancing its adaptability across diverse density scenarios. The Reconstructed Convolution Module is a crucial component that helps distinguish targets from backgrounds, significantly improving feature extraction accuracy. Validated on a meat duck counting dataset in breeding environments, FE-P Net achieved 96.46% accuracy in large-scale settings, demonstrating state-of-the-art performance. The model shows robustness across various densities, providing valuable insights for poultry counting methods in agricultural contexts.

1. Introduction

Recent advancements have boosted demand for poultry products like meat and eggs. Meat ducks, valued for their high-quality proteins and fats [1], grow faster than other poultry, quickly reaching market weight. Proper breeding density is critical for maximizing survival rates and barn space efficiency [2], which are essential for large-scale production and animal welfare. Enhancing breeding efficiency requires real-time monitoring of density and effective management of duck populations. As large-scale breeding emerges as the predominant operational model within the industry, challenges arise when relying exclusively on manual labor for the management of duck houses and the control of breeding density. The need for human observation of extensive surveillance footage not only results in inefficiencies and a heavy reliance on the subjective judgment of personnel, lacking a standardized approach [3]. This not only increases labor intensity and expenses but also poses a barrier to the advancement of the farming sector. By leveraging intelligent farming technologies grounded in deep learning algorithms, it is possible to elevate production efficiency through automation and smart decision-making support systems. These advancements facilitate precise calculation of optimal breeding densities and streamline farming processes. Consequently, while lowering labor costs, they contribute to an overall enhancement in productivity and economic returns [4].

Girshick et al. [5] introduced the R-CNN algorithm, marking a significant advancement in object detection. However, R-CNN was constrained by its requirement for fixed-size candidate regions, leading to slower detection speeds and substantial storage needs for region proposals. To address these limitations, Fast R-CNN [6] and Faster R-CNN [7] were subsequently developed. Fast R-CNN incorporated Spatial Pyramid Pooling (SPP) to accelerate processing, while Faster R-CNN introduced Region Proposal Networks (RPNs) to significantly boost both speed and detection accuracy.

In large-scale breeding, high poultry density often leads to occlusion and crowding. Traditional machine learning methods struggle to perform effectively under such conditions. Zhang et al. [8] pioneered the use of deep learning for crowd counting with a multi-column convolutional neural network, marking the first application of this technique to counting tasks. Although object detection-based counting methods have demonstrated effectiveness, they require significant manual effort for bounding box annotation, which is both costly and time-consuming. In densely occluded real-world settings, these methods often produce inaccurate counts. To overcome these challenges, Cao et al. [9] enhanced the point-supervised localization and counting method proposed by Laradji et al. [10], aiming to enable real-time processing of camera-captured images. By using DenseNet, introduced by Huang et al. [11], as the backbone network and employing point annotation instead of bounding boxes, their approach significantly reduces annotation time and boosts data processing efficiency compared to traditional methods.

Since then, research has advanced these methods, particularly in breeding scenarios. Tian et al. [12] developed a 13-layer convolutional network combining Count CNN [13] and ResNeXt [14] for pig counting, achieving low error rates on sparse datasets. Wu et al. [15] addressed fish counting on dense datasets using dilated convolutions to increase the receptive field without reducing resolution and channel attention modules to enhance feature selection, achieving a mean absolute error (MAE) of 7.07 and a mean squared error (MSE) of 19.16. Li et al. [16] used a multi-column neural network with $1\times 1$ convolutions replacing fully connected layers, resulting in an MAE of 3.33 and MSE of 4.58 on a dataset of 3200 seedling images. Sun et al. [17] introduced a comprehensive dataset of 5637 fish images and proposed an innovative two-branch network that merges convolutional layers with Transformer architectures. By integrating density maps from the convolution branch into the Transformer encoder for regression purposes, their model attained state-of-the-art performance, achieving an MAE of 15.91 and an MSE of 34.08.

Despite these advancements, significant challenges remain in large-scale breeding counting methods. Low-quality images can negatively impact model detection accuracy, while dense scenes further exacerbate the cost and complexity of bounding box annotations. Traditional labeling approaches also face difficulties in achieving precise identification, particularly in areas with severe occlusion and indistinct features.

To address the specified challenges, this study investigates a point-based detection method that reduces data annotation costs and minimizes computational demands by focusing on the approximate positioning of target points rather than bounding box regression. Leveraging PENet [18] and IOCFormer [17], we propose the Feature Enhancement Module with Parallel Network Architecture (FE-P Net), tailored for the current application. FE-P Net comprises two branches: the primary branch employs a Transformer framework with a regression head for final detection outputs, while the auxiliary convolutional branch generates density maps to enhance feature extraction in the primary branch’s encoder. Additionally, to handle low-resolution images common in industrial settings, a Gaussian pyramid module is integrated into the feature extraction process, improving feature representation and mitigating uneven illumination effects. To address feature redundancy caused by low-quality images, spatial and channel reconstruction units are incorporated into the convolutional branch, filtering out irrelevant information and emphasizing crucial features. Our method enhances annotation efficiency and detection accuracy, particularly for livestock farming data, ensuring robust performance under challenging conditions.

2. Materials and Methods

2.1. Image Acquisition for Meat Duck Counting in Large-Scale Farm

The dataset used in this experiment was collected from a poultry house located in Lishui District, Nanjing City. Spanning approximately 500 square meters, the poultry house uses net-bed breeding methods. Data were collected over June and July 2023 using Hikvision Ezviz CS-CB2 (2WF-BK) cameras, which have a resolution of 1920 × 1080 and a viewing angle of about 45°. Over 136 min of video footage were recorded, with frames sampled every 30 s. After filtering out insect-obscured images, 242 usable images were obtained, containing 20,550 meat duck instances, averaging 84.92 instances per image.

As shown in Figure 1a, the collected images exhibit low resolution, significant occlusion between targets, considerable variations in individual sizes, and varying densities across different regions. These factors present substantial challenges for detection tasks.

2.2. Dataset Construction for Meat Duck Counting in Large-Scale Farm

The 242 collected images were randomly split into training and testing sets at a ratio of 7:3, yielding 171 images for the training set and 71 images for the testing set. The images were then annotated using Labelme 4.5.9, with the annotation results shown in Figure 1b.

2.3. Detail-Enhanced Parallel Density Estimation Model Architecture

As shown in Figure 2, our proposed network model combines density-based [19] and regression-based [20] approaches through three key components: the Detail Enhancement Module (DEM), a density branch utilizing convolutional networks, and a regression branch leveraging Transformers.

The DEM enhances edge details using the Laplacian operator and captures multi-scale features via a pyramid module. It highlights duck-specific features while reducing high-frequency background noise through convolutional and pooling operations, thereby mitigating ambiguities caused by low-resolution images. The density branch generates location-sensitive density maps through a convolutional encoder. These maps are shared between the density head and the regression branch, enhancing duck position extraction and preserving spatial context. The regression branch integrates positional information from the density branch with global semantics extracted by the Transformer. This fusion of local details and global context enables highly accurate quantity prediction.

Composed of these components, the architecture ensures synergistic performance, effectively addressing the complexities of large-scale poultry breeding. This enables FE-P Net to achieve accurate meat duck counts even under challenging conditions.

2.3.1. Detail Enhancement Module (DEM)

The overall structure of the DEM is illustrated in Figure 3. It first uses the Laplacian Pyramid Enhancement Model (LPEM) [21], which is based on a pyramid structure, to extract multi-level features from input images. These feature maps are then refined by the Edge Enhancement and Background Noise Reduction Model (EBM), significantly improving their quality and providing a robust foundation for both the density and regression branches. The enhanced high-level features are subsequently upsampled, combined with low-level features, fused with the original image, and finally passed to the encoder.

The Laplacian pyramid employs a $5\times 5$ Gaussian kernel to capture multi-scale information. Each Gaussian pyramid operation halves the image dimensions, reducing the resolution to one-fourth of the original. For an input image $I\in {\mathbb{R}}^{3\times H\times W}$, involving downsampling $Down$ and Gaussian filtering $Gaussian$, the Gaussian pyramid operation is

$$G\left(I\right)=Down\left(Gaussian\right(I\left)\right)$$

(1)

Since Gaussian pyramid downsampling is irreversible and leads to information loss, the Laplacian pyramid is employed to enable the reconstruction of the original image:

$$L_i=G_i-Up\left(G_{i+1}\right)$$

(2)

where $L_i$ and $G_i$ represent the Laplacian pyramid and the Gaussian pyramid at the i-th level, respectively, and $Up$ is the upsampling function. During image reconstruction, the original image resolution can be restored by performing inverse operations. Ultimately, the Laplacian pyramid generates multi-scale features $\{f_0,f_1,f_2\}$.

The EBM was designed to enhance local detail extraction and suppress high-frequency noise. It processes multi-scale information through two components: the Edge Enhancement module (illustrated in Figure 4 and the Low-Frequency Filter module.

The context branch captures global context by modeling remote dependencies and processes them with residual blocks to extract semantic features. For a given feature $f_i\in {\mathbb{R}}^{C\times {\displaystyle \frac{H}{2^i}}\times {\displaystyle \frac{W}{2^i}}}$, with $\gamma$ as a linear activation function, F as a $3\times 3$ convolution operation, $Res$ as a residual block, and $\sigma$ as the Softmax function, the processed feature $f_c$ is defined as:

$$f_c=Res(f_i+\gamma \left(F_1\left(f^{\prime }\right)\right))$$

(3)

$$f^{\prime }=\left(f_i\right)\times \sigma \left(F_2\left(Res\left(f_i\right)\right)\right)$$

(4)

The edge branch utilizes the $Sobelx$ and $Sobely$ operators to process input features, enhancing texture information through gradient extraction. The processed feature $f_e$ is

$$f_e=F_3(f_i+Sobelx\left(f_i\right)+Sobely\left(f_i\right))$$

(5)

The concatenated outputs are fused via convolution to generate the final feature $f_{ce}$.

The Low-Frequency Filter module captures multi-scale low-frequency semantic information, as detailed in Figure 5, enriching the semantic content of images.

For input features $f_i\in {\mathbb{R}}^{3\times H\times W}$, a $1\times 1$ convolution adjusts the channel count to 32, yielding features $f_i\in {\mathbb{R}}^{32\times H\times W}$. These features are then separated into channel-wise and filtered components [22] with adaptive average pooling using kernel sizes of $1\times 1$, $2\times 2$, $3\times 3$, and $6\times 6$, followed by upsampling. The pooling operation is defined is:

$$Pool\left(f_d\right)=Up\left({\beta }_s\left(f_d\right)\right)$$

(6)

Here, $f_d$ represents the feature component after channel separation, $Up$ denotes bilinear interpolation upsampling, and ${\beta }_s$ refers to adaptive average pooling with varying kernel sizes. The resulting feature tensor is concatenated and processed with a convolution operation to recover $f_i\in {\mathbb{R}}^{3\times H\times W}$.

2.3.2. Density Branch Based on Convolutional Networks

CNNs employ fixed-size kernels to capture local semantic information [22], excelling in extracting detailed local features. However, the similarity in color and texture between the background and objects in our dataset necessitates the EBM to differentiate their features. Convolution operations can introduce redundancy by indiscriminately extracting features across both spatial and channel dimensions [23], potentially impacting final predictions. To address this redundancy, this section integrates a Spatial Reconstruction Unit (SRU) and Channel Reconstruction Unit (CRU) into the convolution branch [24]. The structure of the density branch, based on convolutions, is illustrated in Figure 6.

The input features first undergo two sequential $3\times 3$ convolutions to compress the channel dimensions. These features are then refined by SRU and CRU modules to reduce redundancy. Finally, the processed features are used for counting loss calculation and feature fusion in the regression branch. The final expression is

$$f_{sc}=F_1\left(F_2\left(CRU\left(SRU\left(f_{in}\right)\right)\right)\right)$$

(7)

Notably, the convolutional branch incorporates both an SRU and CRU in addition to convolution operations to address information redundancy. The SRU primarily comprises separation and reconstruction stages. The separation stage identifies feature maps rich in spatial information from those with less spatial detail. This is achieved using weight factors from group normalization (GN) layers [25] to evaluate the richness of the feature maps. The GN formula is

$$f_{out}=GN\left(f_{in}\right)=\gamma {\displaystyle \frac{X-\mu }{\sqrt{{\sigma }^2+ϵ}}}+\beta$$

(8)

where $\mu$ and $\sigma$ are the mean and variance of the features in the group, $\gamma$ is a trainable factor that evaluates the richness of the feature mapping, $\beta$ is a bias parameter, and $ϵ$ is a small positive number to avoid division by zero. To unify the sample distribution and accelerate network convergence, normalization layers process the trainable parameter $\gamma \in {\mathbb{R}}^C$, yielding the normalized weights $W_{\gamma }$. The expression is as follows:

$$W_{\gamma }=\left\{w_i\right\}={\displaystyle \frac{{\gamma }_i}{{\sum }_{j=1}^C{\gamma }_j}},i,j=1,2,\dots ,C$$

(9)

After obtaining the normalized weights, the $sigmoid$ function processes the weight vector to amplify differences between rich features and coefficient features. The gating unit then inputs the processed weight vectors into two directions. Based on a set threshold $\theta$, elements greater than $\theta$ are set to 1 ($W_1$), and those less than or equal to $\theta$ are set to 0 ($W_2$). The expression for $W_i\in 1,2$ is as follows:

$$W_i=Threshold\left(Sigmoid\left(W_{\gamma }\right)\right)$$

(10)

The threshold operation generates two weight vectors, which are then multiplied by the input features to generate $X_1$ and $X_2$. $X_1$ contains richer feature information, while $X_2$ contains less semantic information. To eliminate redundancy while preserving features, a spatial reconstruction module is designed to restructure the features.

Traditional convolution operations, which use fixed-size kernels for feature extraction along each channel, can introduce channel redundancy. To address this, the CRU module employs a separation and fusion strategy. Specifically, the input features are grouped, and $1\times 1$ convolutions are applied to compress the channels of these groups, thereby reducing computational costs. The key components GWC [26] and PWC [27] minimize channel redundancy: GWC applies $k\times k$ convolutions to the grouped feature maps, while PWC uses $1\times 1$ convolutions to enhance inter-channel communication. The final output is refined to reduce redundancy and improve efficiency:

$$Y_1=M^G{X}_{up}+M^{P1}{X}_{up}$$

(11)

where $M^G\in {\mathbb{R}}^{{\displaystyle \frac{ac}{gr}}\times k\times k\times ac}$ is the trainable weight parameter of the GWC module, and $M^{P1}\in {\mathbb{R}}^{{\displaystyle \frac{ac}{r}}\times 1\times 1\times ac}$ is the learnable parameter of the PWC module in the upper branch. Additionally, $X_{up}\in {\mathbb{R}}^{{\displaystyle \frac{ac}{r}}\times h\times w}$ is the input to the upper branch.

The lower branch concatenates the PWC-processed image with the original input to obtain the output $Y_2$:

$$Y_2=concat(M^{P2}{X}_{low},X_{low})$$

(12)

where $M^{P2}\in {\mathbb{R}}^{{\displaystyle \frac{(1-a)c}{r}}\times 1\times 1\times (1-a)c}$ is the trainable parameter of the PWC module in the lower branch, and $X_{low}\in {\mathbb{R}}^{{\displaystyle \frac{(1-a)c}{r}}\times w\times h}$ is the input to the lower branch.

The features from both branches are then fused. First, the features are concatenated and undergo adaptive pooling to obtain the pooled feature weight vector S:

$$S_m=Pooling\left(Y_m\right)={\displaystyle \frac{1}{H\times W}}\sum _{i=1}^H\sum _{j=1}^W{Y}_c(i,j)$$

(13)

The obtained weight vector is then used as a weighting coefficient to scale the original features. Finally, with $s1$ and $s2$ representing the sums of vectors derived from adaptive average pooling operations, the weighted features are aggregated to produce final output:

$$Y={\displaystyle \frac{e^{s_1}}{e^{s_1}+e^{s_2}}}{Y}_1+{\displaystyle \frac{e^{s_2}}{e^{s_1}+e^{s_2}}}{Y}_2$$

(14)

2.3.3. Regression Branch Based on Transformer

The regression branch comprises three main components: a density-enhanced encoder based on the Transformer (DETE), a Transformer decoder [28], and a regression head. Unlike traditional Transformer encoders, the DETE module enhances feature extraction by integrating outputs from a convolutional branch. This integration enables more precise capture of both global semantic information and local detail features, improving the precision of duck localization and quantity estimation. The detailed architecture of the DETE module is illustrated in Figure 7.

The module maps the information extracted by the detail enhancement module to $F\in {\mathbb{R}}^{w\times h\times c}$ while simultaneously mapping the features extracted by the density branch to $F_d\in {\mathbb{R}}^{w\times h\times c}$. These features are then combined with positional embeddings $E\in {\mathbb{R}}^{w\times h\times c}$ and fed into a Transformer layer. The expressions for this process are as follows:

$$F^1=Rs\left(F\right)+Rs\left(F_d\right)+E$$

(15)

$$F^2=Trans\left(F^1\right)$$

(16)

Here, $Rs\left(\right)$ represents the flattening of feature maps for subsequent Transformer processing, and $Trans\left(\right)$ represents the Transformer layer. The module consists of four layers, with each layer processing features as follows:

$$F_d^1=F_d$$

(17)

$$F_d^i=Convs\left(F_d^{i-1}\right),i=2,3,\dots ,L-1$$

(18)

$$F^{i+1}=Trans(F^i+Rs\left(F_d^i\right)),i=2,3,\dots ,L-1$$

(19)

where $Convs$ represents convolution operations. The DETE module merges the output of the previous layer with the convolved density features before each Transformer layer. This process gradually combines global and local information, enabling the extraction of richer and more accurate features. After processing by the DETE module, the resulting feature maps contain precise information. The Transformer decoder then takes the obtained features $F_L$ and trainable query vectors $Q\in {\mathbb{R}}^{n\times c}$ as inputs, and outputs the decoded embedding vectors $\widehat{Q}\in {\mathbb{R}}^{n\times c}$.

2.3.4. Loss Function

After forward propagation, the classification head maps the output to a confidence score vector, and the regression head maps it to point coordinates [20]. Assuming the query results are ${\{p_i,(\widehat{x_i},\widehat{y_i})\}}_{i=1}^n$, where $p_i$ is the predicted confidence score for the pixel corresponding to the target, and $(\widehat{x_i},\widehat{y_i})$ are the network-predicted coordinates. These predictions are compared with ground truth points ${(x_i,y_i)}_{i=1}^K$. By setting $n>K$, each ground truth point can be matched with one prediction using the Hungarian algorithm [29]. To compute the average distance difference, first the average distances from the prediction to other points and from the corresponding ground truth to other points are calculated. For the i-th ground truth point $X_i=(x_i,y_i)$ and its corresponding prediction point $Y_i=(\widehat{x_i},\widehat{y_i})$, first the average distances $d_i$ and $\widehat{d_i}$ are computed:

$$d_i={\displaystyle \frac{1}{K}}\sum _{k=1}^K{d}_i^k,\widehat{d_i}={\displaystyle \frac{1}{K}}\sum _{k=1}^K\widehat{d_i^k}$$

(20)

With $C_i$ being the confidence score of the i-th prediction point, the cost function is

$$D=\left|\right|X_i-Y_i{\left|\right|}_1-\left|\right|d_i-\widehat{d_i}{\left|\right|}_1-C_i$$

(21)

After determining the matching relationships between prediction points and ground truth points, the classification loss $L_C$ evaluates the confidence loss for each point. A higher loss function value indicates that the features around the point are more distinct from the target object. This loss is calculated using binary cross-entropy:

$$L_C=-\sum _{i=1}^{K}log\left[Sigmoid\left(C_i\right)\right]$$

(22)

During loss calculation, the predicted confidence values are first mapped to the range [0, 1]. To make the predicted coordinates closer to the true values, the classification loss $L_l$ is used to express the difference between predictions and labels:

$$L_l=\sum _{i=1}^K\left[\right|\widehat{y_i}-y_i|+|\widehat{x_i}-x_i\left|\right]$$

(23)

With $\lambda$ being the weight for the density branch loss, and $L_D$ denoting the density branch loss. The overall loss function is

$$L=\lambda L_D+L_C+L_l$$

(24)

2.4. Implementation Details

The experiment used Linux Ubuntu 20.04 with 32 GB RAM and a 2080Ti GPU, using Python 3.7.13 and PyTorch 1.13.0. The parameters were initialized using the Kaiming uniform distribution initialization method. The Adam optimizer was used with a weight decay of 0.0005. Training ran for 3500 iters with an initial learning rate of 0.00001, which was reduced to 0.1 times its value at the 1200th epoch using MultiStepLR.

2.5. Evaluation Metrics

The evaluation metrics used for flow counting were MAE and MSE. MAE measures the difference between predicted individual counts and ground truth counts:

$$MAE={\displaystyle \frac{1}{N}}\sum _{i=1}^N|X_i^p-X_i^l|$$

(25)

where N is the quantity of prediction images, $X_i^p$ and $X_i^l$ are the predicted and true values for the i-th image, respectively, and $\left|\right|$ denotes the absolute value. In counting tasks, MAE represents the average error in estimating individual counts; a smaller MAE indicates more accurate predictions. However, MAE does not highlight outliers. MSE, which uses squared differences to emphasize larger errors and highlight outliers, is defined by the formula:

$$MSE={\displaystyle \frac{1}{N}}\sum _{i=1}^N{(X_i^p-X_i^l)}^2$$

(26)

3. Results

3.1. Count Result Analysis

Figure 8 shows the prediction results of our method. Specifically, (a) represents the original images in the dataset, (b) shows the visualized label values generated from the annotation files, (c) displays the density map predicted by the convolution branch, and (d) shows the coordinate results regressed by the regression branch.

Table 1. Comparison of counting accuracy among models.

Model Name	MAE	MSE	Accuracy
CCST	3.89	4.69	95.41%
MAN	4.18	5.32	95.08%
MFF	5.93	7.16	93.01%
TransCrowd	3.95	5.03	95.35%
P2PNet	4.64	5.11	94.53%
IOC	4.15	4.95	95.11%
FE-P	3.01	4.21	96.46%

The bold values represent the optimal performance.

compares the segmentation accuracy of various models on the broiler counting dataset. Compared to the classical convolutional networks MFF [30] and P2PNet [31], our method improves MAE by 2.92 and 1.63, and improves MSE by 2.95 and 0.90, achieving accuracy improvements of 3.45% and 1.68%, respectively. Compared to Transformer-based models MAN [32] and CCST [33], our method improves the MAE by 1.14 and 0.87, and MSE by 1.11 and 0.48, achieving improvements of 1.38% and 1.01%, respectively. Overall, Transformer-based detectors show higher accuracy than convolutional network-based detectors. This is because convolution operations are sensitive to fine-grained local semantic information but can fail to some extent when extracting features from low-resolution images. Our method achieved a mean absolute error of 3.02 and an accuracy of 96.46% on the meat duck dataset, showing improvements over other models, which means that our method can better detect individual broilers in poultry house environments.

Figure 9 shows that Transformer-based networks excel in high-density scenarios, while convolution-based networks perform better in low-density areas. Transformers use an attention mechanism to capture long-range dependencies, improving detection of closely spaced objects without misidentifying the background. In contrast, convolutional networks effectively capture local features and edges due to their receptive fields, aiding precise object localization. Our method integrates density features from convolution branches with Transformer-extracted features using a density-fused Transformer encoder. This approach balances global semantics and local details, enhancing overall detection performance.

3.2. Ablation Experiments

Ablation experiments were conducted to evaluate the impact of the various substructures on model performance. Our method includes two branches and a detail enhancement module. Several ablation studies were designed to validate their effectiveness, with the results shown in

Table 2. Ablation experiments for the different modules.

LPEM	CNN Branch	SCCONV	MAE	MSE
×	×	×	8.44	10.29
×	✔	×	4.15	4.95
✔	✔	×	3.56	4.32
✔	✔	✔	3.01	4.15

A ✔ symbol indicates that the module has been added and a × symbol indicates that the module has not been added. The bold values represent the optimal performance.

.

Without the convolution branch, the model’s MAE increased to 8.44 and the MSE to 10.29. This increase is attributed to the failure of the density-enhanced Transformer encoder and the counting loss strategy used by the convolution branch, rendering the loss strategy ineffective. Adding the convolution branch significantly improved performance, reducing MAE to 4.15 and MSE to 4.95. Incorporating the LPEM module further enhanced feature representation, mitigating low-resolution image issues and improving object localization and edge detection, which lowered the MSE to 3.56. Finally, adding the SCCONV module to the convolution branch eliminated feature redundancy, allowing the Transformer encoder to integrate more precise features and reduce noise, ultimately lowering the error to 3.01. These experiments demonstrate the positive contributions of each module and validate the superiority of the dual-branch structure.

The encoder plays a crucial role in feature extraction, generating feature maps from input images to support subsequent detection tasks. Selecting an appropriate feature extraction network can significantly enhance model performance. This section evaluates the use of different feature extraction networks as the backbone encoder through a series of experiments, with the results shown in

Table 3. Ablation experiments for the different feature extraction networks.

Encoder	MAE	MSE	Accuracy
ResNet-18	3.93	4.77	95.37%
ResNet-34	3.76	4.63	95.57%
ResNet-50	3.02	4.15	96.46%
ResNet-101	3.62	4.67	95.73%

The bold values represent the optimal performance.

.

The experimental results indicate that using ResNet-50 [34] as the backbone encoder achieves the best performance. Shallower networks such as ResNet-18 and ResNet-34 offer faster inference but provide less comprehensive feature extraction, leading to reduced accuracy. In contrast, using ResNet-101 as the encoder results in over-extraction due to its deeper layers, which also decreases accuracy.

4. Conclusions

In practical production environments, image quality is often low, and traditional bounding box annotation methods are labor-intensive. Our study introduces the FE-P Net architecture, which uses point annotations combined with a feature enhancement module to refine image features and improve detection accuracy. This approach offers a novel solution for enhancing poultry counting accuracy in farming scenarios.

Unlike existing methods that struggle with low-resolution images, FE-P Net employs a dual-branch architecture to integrate local detail extraction and global semantic understanding. By refining edge details and enhancing feature representations while reducing redundancy in both the spatial and channel dimensions, FE-P Net effectively mitigates issues related to low resolution, blurred edges, and uneven lighting. This results in significant performance improvements, achieving 96.46% accuracy on the meat duck dataset. Comparative experiments confirm that FE-P Net outperforms other models on this dataset, successfully completing the counting task. Ablation studies further validate the contributions of each module to overall network performance.

The findings have profound practical implications for poultry breeding. Deploying FE-P Net in real-time monitoring systems enables automated and accurate population counts, crucial for optimizing space utilization, improving animal welfare, and enhancing farm management efficiency. The use of point annotations significantly reduces the labor required for labeling, facilitating scalable deployment across large farming operations. However, there are areas for improvement. Eye-based point annotations require precise calibration, especially in highly crowded scenes with frequent occlusions. Further research should explore the model’s robustness under varying lighting and environmental conditions. Combining FE-P Net with larger models could enhance performance and adaptability.

In conclusion, this study advances the application of deep learning techniques in poultry breeding management. By addressing key challenges in image quality and object density, FE-P Net provides a promising solution for automating meat duck counting. As agriculture continues its digital transformation, innovations like ours will be essential in driving productivity and sustainability.