Pathogen carrying detection system based on deep learning

Abstract

The invention relates to the field of public health, in particular to a pathogen carrying detection system based on deep learning, which comprises a data acquisition module, a feature extraction module, a deep learning module, a pathogen detection module and a monitoring management module. A feature extraction model is constructed in combination with combined parallel and sequential strategies, and noise interference in the detection process is reduced through residual learning, dynamic up-sampling and conditional random field processing; in the deep learning module, a jump residual method is used to classify and identify an output feature image, a YOLOv8-based infrastructure is combined with the jump residual method, noise interference of the feature image is reduced through fuzzy processing, and a conditional random field further optimizes a pixel context relationship. And the detection precision, robustness and efficiency are obviously improved.

Description

Technical Field

[0001] The present invention relates to the field of public health, and specifically refers to a pathogen-carrying detection system based on deep learning. Background Art

[0002] In recent years, with the frequent occurrence of public health events, pathogen detection technology based on deep learning has gradually become an important direction in medical research. Most of the existing pathogen-carrying detection systems have the problem of low detection accuracy. Due to the deviation in the collection of pathogen images, the detailed features of the images are lost, and the detection process is easily interfered by image noise or molecular data, resulting in incorrect detection results. Summary of the Invention

[0003] In view of the above situation, to overcome the defects of the prior art, the present invention provides a pathogen-carrying detection system based on deep learning. Aiming at the problem that most of the existing pathogen-carrying detection systems have low detection accuracy, the present invention introduces a U-Net structure based on Swin Transformer into the feature extraction module, and constructs a feature extraction model by combining a combined parallel and sequential strategy. The local attention mechanism of Swin Transformer captures the fine-grained features of the image, and the skip connections of U-Net retain the global semantics and local detail information. At the same time, through residual learning, dynamic upsampling and conditional random field processing, the noise interference in the detection process is reduced, and a clearer pathogen recognition result is output. In the deep learning module of the present invention, a skip residual method is used to classify and identify the output feature image. Combining the basic architecture of YOLOv8 with the skip residual method improves the efficiency of feature extraction and classification. Through the skip residual method, multi-layer feature extraction is introduced, and key information is retained during each residual learning process, alleviating the problems of gradient disappearance and overfitting, significantly improving the detection accuracy, and at the same time reducing the noise interference of the feature map through blurring processing. The conditional random field further optimizes the pixel context relationship. The detection accuracy, robustness and efficiency are significantly improved, and the applicability and reliability of the system are also enhanced, meeting the high standards of pathogen detection in the modern public health field.

[0004] The technical solution adopted by the present invention is as follows: The pathogen-carrying detection system based on deep learning provided by the present invention is mainly used to detect the pathogens carried by mosquitoes at the national border ports, including a data acquisition module, a feature extraction module, a deep learning module, a pathogen detection module and a monitoring and management module, and specifically includes the following:

[0005] The data acquisition module collects mosquito samples at the national border ports, captures the image data of the mosquito samples by using a microscope, and performs PCR detection on the mosquito samples to obtain the molecular data of the mosquito samples;

[0006] The feature extraction module constructs a feature extraction model based on the U-Net structure of Swin Transformer, combines the combined parallel and sequential strategies, and obtains the output feature map of the mosquito sample according to the image data and molecular data of the mosquito sample;

[0007] The deep learning module uses the basic architecture based on YOLOv8 and the skip residual method to classify and identify the output feature image, and obtains the recognition result;

[0008] The pathogen detection module extracts viral nucleic acids from the captured mosquito samples, and combines the recognition results obtained by the deep learning module to obtain the detection results;

[0009] The monitoring and management module stores and manages the detection results, and visualizes the change trend of the detection results.

[0010] Furthermore, in the feature extraction module, based on the U-Net structure of Swin Transformer, a feature extraction model is constructed by combining the combined parallel and sequential strategies. The specific implementation steps are as follows:

[0011] Step S1: Data preparation, collect historical mosquito image data and mosquito molecular data and merge them to construct a dataset, which is divided into a training set, a validation set and a test set according to the ratio of 6:2:2;

[0012] Step S2: Model construction, construct a feature extraction model according to the U-Net model based on Swin Transformer, including an encoder and a decoder. Insert LoRA and Adapter modules in the encoder, and use the combined parallel and sequential strategies to optimize the parameters of the feature extraction model. The decoder adopts the U-Net decoder structure;

[0013] Step S3: Model architecture adjustment, utilize the local feature extraction ability of Swin Transformer to block and feature aggregate the historical mosquito image data to obtain image features, add an independent feature extraction module, use a multi-layer perceptron to convert the historical mosquito molecular data into molecular features, introduce a feature fusion module in the encoder, combine the historical mosquito image features and molecular features to generate a joint feature map, and the decoder restores the joint feature map to an output feature map through skip connections and combines high-resolution features;

[0014] Step S4: Model training, use the training set as input, generate a joint feature map through the encoder, transfer it to the decoder for restoration to obtain an output feature map, set the loss function by combining Dice loss and cross-entropy loss, and freeze the weights of the encoder at the beginning of training, and only train the LoRA and Adapter modules in parallel;

[0015] Step S5: Model testing, evaluating the Dice coefficient and HD95 metric of the feature extraction model on the validation set;

[0016] Step S6: Feature extraction application, using the trained model to extract features from the mosquito samples collected by the data acquisition module at the national border ports to obtain the output feature map of the mosquito samples.

[0017] Furthermore, in the deep learning module, classification and recognition are performed based on the basic architecture of YOLOv8 and the skip residual method, which specifically includes the following steps:

[0018] Step Q1: Data input, receiving the output feature map of the mosquito samples, performing normalization processing to obtain the processed feature map, using the YOLOv8 model as the basic architecture to construct a pathogen recognition model, and introducing a residual learning part, a feature enhancement part, a conditional random field, and a dynamic upsampling part;

[0019] Step Q2: First residual learning, setting a first sub-residual block and a second sub-residual block in the residual learning part, inputting the processed feature map into the first sub-residual block, and the first sub-residual block extracts features through a convolutional layer and calculates the residual through a skip connection to obtain the residual feature value ;

[0020] Step Q3: Feature enhancement, through the feature enhancement part, generating a spatial attention mask through 1×1 convolution and Softmax operation, and combining the residual feature value and the spatial attention mask to generate a feature representation ;

[0021] Step Q4: Second residual learning, inputting the feature representation into the second sub-residual block, and obtaining the residual feature value through convolutional operation and residual connection ;

[0022] Step Q5: Blurring processing, performing blurring processing on the residual feature value , using the Gaussian function to smooth the residual feature value to obtain the blurred output feature map;

[0023] Step Q6: Feature enhancement, combining the blurred output feature map and the output feature map of the unprocessed mosquito samples in Step Q1 through residual connection to obtain a high-resolution feature map;

[0024] Step Q7: Conditional random field processing, optimizing the high-resolution feature map based on the context relationship between pixels;

[0025] Step Q8: Dynamic upsampling. Based on step Q7, generate an adaptive offset through static and dynamic scaling factors, and dynamically adjust the sampling point positions through the adaptive offset to obtain the final pathogen recognition map;

[0026] Step Q9: Classification and recognition. Construct a classification model based on a deep neural network, and perform classification processing on the pathogen recognition map generated in step Q8 to obtain the recognition result.

[0027] Further, step Q8 specifically includes the following contents:

[0028] Generate an adaptive offset through static and dynamic scaling factors: The static scaling factor is a preset fixed sampling multiple, and the dynamic scaling factor is a preset sampling point adjustment parameter;

[0029] Dynamic offset calculation: Use the dynamic scaling factor to predict the offset of the sampling point. Extract features through the convolutional layer and combine with the Sigmoid activation function to generate the offset value of each pixel, and obtain the dynamically adjusted sampling point positions;

[0030] Adjust the sampling point positions: Use the dynamically adjusted sampling point positions to perform interpolation calculation on the high-resolution feature map to obtain the final pathogen recognition map.

[0031] The beneficial effects achieved by the present invention using the above solution are as follows:

[0032] (1) In view of the above situation, to overcome the defects of the prior art, the present invention provides a pathogen carriage detection system based on deep learning. Aiming at the problem that most of the existing pathogen carriage detection systems have low detection accuracy, the present invention introduces a U-Net structure based on Swin Transformer into the feature extraction module, constructs a feature extraction model by combining a combined parallel and sequential strategy. The local attention mechanism of Swin Transformer captures the fine-grained features of the image, and the skip connections of U-Net retain the global semantics and local detail information. At the same time, through residual learning, dynamic upsampling and conditional random field processing, the noise interference in the detection process is reduced, and a clearer pathogen recognition result is output;

[0033] (2) In the deep learning module of the present invention, the skip residual method is used to classify and identify the output feature images. Based on the architecture of YOLOv8 combined with the skip residual method, the efficiency of feature extraction and classification is improved. Through the skip residual method, multi-layer feature extraction is introduced, and key information is retained during each residual learning process, reducing the problems of gradient disappearance and overfitting, significantly improving the detection accuracy. At the same time, the noise interference of the feature map is reduced through blurring processing, and the conditional random field further optimizes the pixel context relationship. It significantly improves the detection accuracy, robustness, and efficiency, and also enhances the applicability and reliability of the system, meeting the high standards required for pathogen detection in the modern public health field. BRIEF DESCRIPTION OF THE DRAWINGS

[0034] Figure 1 It is a schematic diagram of the pathogen-carrying detection system based on deep learning proposed by the present invention.

[0035] The drawings are used to provide a further understanding of the present invention and constitute a part of the specification. Together with the embodiments of the present invention, they are used to explain the present invention and do not constitute a limitation to the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0036] Next, the technical solutions in the embodiments of the present invention will be clearly and completely described in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only a part of the embodiments of the present invention, rather than all the embodiments; based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the scope of protection of the present invention.

[0037] Embodiment 1, refer to Figure 1 The technical solutions adopted by the present invention are as follows: The pathogen-carrying detection system based on deep learning provided by the present invention mainly detects the pathogens carried by mosquitoes at the national border ports, including a data acquisition module, a feature extraction module, a deep learning module, a pathogen detection module, and a monitoring and management module, specifically including the following:

[0038] The data acquisition module collects mosquito samples at the national border ports, captures the image data of the mosquito samples using a microscope, and obtains the molecular data of the mosquito samples through PCR detection of the mosquito samples;

[0039] The feature extraction module constructs a feature extraction model based on the U-Net structure of Swin Transformer, combining the combined parallel and sequential strategies, and obtains the output feature map of the mosquito samples according to the image data and molecular data of the mosquito samples;

[0040] The deep learning module performs classification and identification based on the architecture of YOLOv8 and the skip residual method to obtain the identification result;

[0041] The pathogen detection module extracts viral nucleic acids from the captured mosquito samples, and combines with the recognition results obtained by the deep learning module to obtain the detection results;

[0042] The monitoring and management module stores and manages the detection results, and visualizes the change trend of the detection results.

[0043] Example 2. This example is based on the above example. In the feature extraction module, based on the U-Net structure of Swin Transformer, a feature extraction model is constructed by combining the combined parallel and sequential strategies. The specific implementation steps are as follows:

[0044] Step S1: Data preparation. Collect historical mosquito image data and mosquito molecular data and merge them to construct a dataset, which is divided into a training set, a validation set, and a test set according to the ratio of 6:2:2;

[0045] Step S2: Model construction. Construct a feature extraction model according to the U-Net model based on Swin Transformer, including an encoder and a decoder. Insert LoRA and Adapter modules in the encoder, and use the combined parallel and sequential strategies to optimize the parameters of the feature extraction model. The decoder adopts the U-Net decoder structure;

[0046] Step S3: Model architecture adjustment. Utilize the local feature extraction ability of Swin Transformer to divide and aggregate the features of historical mosquito image data to obtain image features. Add an independent feature extraction module, and use a multi-layer perceptron to convert the historical mosquito molecular data into molecular features. Introduce a feature fusion module in the encoder to combine the image features and molecular features of historical mosquitoes to generate a joint feature map. The decoder restores the joint feature map to an output feature map by combining high-resolution features through skip connections;

[0047] Step S4: Model training. Use the training set as the input, generate a joint feature map through the encoder, transfer it to the decoder for restoration to obtain an output feature map, set the loss function by combining the Dice loss and the cross-entropy loss, and freeze the weights of the encoder at the beginning of training, and only train the LoRA and Adapter modules in parallel;

[0048] Step S5: Model testing. Evaluate the Dice coefficient and HD95 index of the feature extraction model on the validation set;

[0049] Step S6: Feature extraction application. Use the trained model to extract features from the mosquito samples collected by the data acquisition module at the national border port to obtain the output feature map of the mosquito samples.

[0050] In this embodiment, in step S1, the image data is normalized, including resizing the image to 224×224 pixels and normalizing the color space. The molecular data is filtered using chimeric sequences and screened by quality scores to remove noise and low-quality data. The image data is matched one by one with the corresponding molecular data to construct a dataset;

[0051] In step S2, the encoder part: The Swin Transformer is used to extract local features from the image data. The patch size is 4×4 and the stride is 4. The LoRA module and the Adapter module are inserted at each level to reduce the model parameter quantity and improve the training efficiency;

[0052] The decoder part: The U-Net decoder is adopted to fuse high-resolution features and low-resolution features through layer-by-layer skip connections, and gradually restore the feature map.

[0053] Embodiment 3, this embodiment is based on the above embodiment, and in the deep learning module, classification and recognition are performed based on the basic architecture of YOLOv8 and the skip residual method, specifically including the following steps:

[0054] Step Q1: Data input, receive the output feature map of the mosquito sample, perform normalization processing to obtain the processed feature map, use the YOLOv8 model as the basic architecture to construct a pathogen recognition model, and introduce a residual learning part, a feature enhancement part, a conditional random field, and a dynamic upsampling part;

[0055] Step Q2: First residual learning, set the first sub-residual block and the second sub-residual block in the residual learning part, input the processed feature map into the first sub-residual block, and the first sub-residual block extracts features through the convolutional layer and calculates the residual through the skip connection to obtain the residual feature value ;

[0056] Step Q3: Feature enhancement, through the feature enhancement part, generate a spatial attention mask through 1×1 convolution and Softmax operation, and combine the residual feature value and the spatial attention mask to generate a feature representation ;

[0057] Step Q4: Second residual learning, input the feature representation into the second sub-residual block, and obtain the residual feature value through convolutional operation and residual connection ;

[0058] Step Q5: Blurring process, perform blurring processing on the residual feature value , use the Gaussian function to smooth the residual feature value to obtain the blurred output feature map;

[0059] Step Q6: Feature Enhancement. Combine the feature map of the fuzzy output and the output feature map of the unprocessed mosquito samples in Step Q1 through residual connection to obtain a high-resolution feature map.

[0060] Step Q7: Conditional Random Field Processing. Optimize the high-resolution feature map based on the contextual relationship between pixels.

[0061] Step Q8: Dynamic Upsampling. Generate an adaptive offset based on static and dynamic scaling factors on the basis of Step Q7, and dynamically adjust the sampling point positions through the adaptive offset to obtain the final pathogen recognition map.

[0062] Step Q9: Classification and Recognition. Construct a classification model based on a deep neural network, and perform classification processing on the pathogen recognition map generated in Step Q8 to obtain the recognition result.

[0063] In this embodiment, the core code used is as follows:

[0064] import torch

[0065] import torch.nn as nn

[0066] import torch.nn.functional as F

[0067] # Define the skip residual block

[0068] class ResidualBlock(nn.Module):

[0069] def __init__(self, in_channels, out_channels):

[0070] super(ResidualBlock, self).__init__()

[0071] self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1)

[0072] self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1)

[0073] self.bn1 = nn.BatchNorm2d(out_channels)

[0074] self.bn2 = nn.BatchNorm2d(out_channels)

[0075] self.relu = nn.ReLU()

[0076] def forward(self, x):

[0077] residual = x

[0078] x = self.conv1(x)

[0079] x = self.bn1(x)

[0080] x = self.relu(x)

[0081] x = self.conv2(x)

[0082] x = self.bn2(x)

[0083] x += residual

[0084] x = self.relu(x)

[0085] return x

[0086] # Define the feature enhancement module

[0087] class FeatureEnhancementModule(nn.Module):

[0088] def __init__(self, in_channels):

[0089] super(FeatureEnhancementModule, self).__init__()

[0090] self.conv1x1 = nn.Conv2d(in_channels, in_channels, kernel_size=1)

[0091] self.softmax = nn.Softmax(dim=1)

[0092] def forward(self, x):

[0093] # Use 1x1 convolution for feature enhancement

[0094] x = self.conv1x1(x)

[0095] attention_map = self.softmax(x)

[0096] enhanced_features = x * attention_map # Weighted features

[0097] return enhanced_features

[0098] # Define the dynamic upsampling module

[0099] class DynamicUpsamplingModule(nn.Module):

[0100] def __init__(self, in_channels):

[0101] super(DynamicUpsamplingModule, self).__init__()

[0102] self.conv = nn.Conv2d(in_channels, in_channels, kernel_size = 3, padding = 1)

[0103] self.sigmoid = nn.Sigmoid()

[0104] def forward(self, x, scale_factor = 2):

[0105] # Dynamic upsampling adjusts the sampling position through convolution operations and adaptive offsets

[0106] x = F.interpolate(x, scale_factor = scale_factor, mode = 'bilinear', align_corners = True)

[0107] x = self.conv(x)

[0108] return x

[0109] # Define the model

[0110] class PathogenDetectionModel(nn.Module):

[0111] def __init__(self, in_channels, num_classes):

[0112] super(PathogenDetectionModel, self).__init__()

[0113] self.residual_block1 = ResidualBlock(in_channels, 64)

[0114] self.residual_block2 = ResidualBlock(64, 128)

[0115] self.feature_enhancement = FeatureEnhancementModule(128)

[0116] self.residual_block3 = ResidualBlock(128, 256)

[0117] self.dynamic_upsampling = DynamicUpsamplingModule(256)

[0118] self.fc = nn.Linear(256, num_classes)

[0119] def forward(self, x):

[0120] # Data input and processing

[0121] x = self.residual_block1(x)

[0122] x = self.residual_block2(x)

[0123] x = self.feature_enhancement(x)

[0124] x = self.residual_block3(x)

[0125] x = self.dynamic_upsampling(x)

[0126] # Classification and recognition

[0127] x = x.view(x.size(0), -1) # Flatten

[0128] x = self.fc(x)

[0129] return x

[0130] # Model training and testing

[0131] def train(model, train_loader, criterion, optimizer, device):

[0132] model.train()

[0133] for images, labels in train_loader:

[0134] images, labels = images.to(device), labels.to(device)

[0135] optimizer.zero_grad()

[0136] outputs = model(images)

[0137] loss = criterion(outputs, labels)

[0138] loss.backward()

[0139] optimizer.step()

[0140] def test(model, test_loader, criterion, device):

[0141] model.eval()

[0142] correct = 0

[0143] total = 0

[0144] with torch.no_grad():

[0145] for images, labels in test_loader:

[0146] images, labels = images.to(device), labels.to(device)

[0147] outputs = model(images)

[0148] _, predicted = torch.max(outputs.data, 1)

[0149] total += labels.size(0)

[0150] correct += (predicted == labels).sum().item()

[0151] accuracy = 100 * correct / total

[0152] return accuracy

[0153] # Simulate data loaders and training process

[0154] if __name__ == "__main__":

[0155] # Set the device

[0156] device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

[0157] # Simulate datasets (e.g., mosquito images and labels)

[0158] train_loader = [(torch.rand(8, 3, 224, 224), torch.randint(0, 2, (8,))) for _ in range(100)] # Assume 100 training samples

[0159] test_loader = [(torch.rand(8, 3, 224, 224), torch.randint(0, 2, (8,))) for _ in range(20)] # Assume 20 test samples

[0160] # Initialize the model, loss function, and optimizer

[0161] model = PathogenDetectionModel(in_channels=3, num_classes=2).to(device)

[0162] criterion = nn.CrossEntropyLoss()

[0163] optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

[0164] # Training and testing

[0165] for epoch in range(10): # Train for 10 epochs

[0166] train(model, train_loader, criterion, optimizer, device)

[0167] accuracy = test(model, test_loader, criterion, device)

[0168] print(f"Epoch [{epoch+1} / 10], Test Accuracy: {accuracy:.2f}%")

[0169] Example 4, this example is based on the above example, step Q8, specifically includes the following content:

[0170] Generate an adaptive offset through static and dynamic scaling factors: The static scaling factor is a preset fixed sampling multiple, and the dynamic scaling factor is a preset sampling point adjustment parameter;

[0171] Dynamic offset calculation: Use the dynamic scaling factor to predict the offset of the sampling points. Use the dynamic scaling factor to predict the offset of the sampling points. Extract features through a convolutional layer and combine with the Sigmoid activation function to generate the offset value of each pixel, and obtain the position of the dynamically adjusted sampling points;

[0172] Adjust the sampling point position: Use the position of the dynamically adjusted sampling points to perform interpolation calculation on the high-resolution feature map to obtain the final pathogen recognition map.

[0173] It should be noted that, in this document, relational terms such as first and second are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any actual relationship or order between these entities or operations. Moreover, the terms "comprising", "including" or any other variant thereof are intended to cover non-exclusive inclusion, such that a process, method, article or device comprising a series of elements not only includes those elements but also includes other elements not expressly listed, or elements inherent to such process, method, article or device.

[0174] Although the embodiments of the present invention have been shown and described, it will be understood by those of ordinary skill in the art that various changes, modifications, substitutions and variations can be made to these embodiments without departing from the principles and spirit of the present invention, and the scope of the present invention is defined by the appended claims and their equivalents.

[0175] The above describes the present invention and its implementation manners. Such description is not restrictive. What is shown in the drawings is only one of the implementation manners of the present invention, and the actual structure is not limited thereto. Generally speaking, if those of ordinary skill in the art are inspired by it and, without departing from the purpose of the present invention, design similar structural modes and embodiments to this technical solution without creative efforts, they should all fall within the protection scope of the present invention.

Claims

1. A pathogen detection system based on deep learning, characterized by: It includes data collection module, feature extraction module, deep learning module, pathogen detection module and monitoring management module, specifically including the following contents: The data collection module collects mosquito samples at the border port, captures image data of the mosquito samples using a microscope, and performs PCR testing on the mosquito samples to obtain molecular data of the mosquito samples; The feature extraction module is based on the U-Net structure of Swin Transformer, combines the combination of parallel and sequential strategies to build a feature extraction model, and obtains the output feature map of the mosquito sample according to the image data and molecular data of the mosquito sample; The deep learning module uses a jump residual method to classify and identify the output feature image to obtain a recognition result; The pathogen detection module extracts viral nucleic acid from captured mosquito samples and obtains detection results based on the recognition results obtained by the deep learning module; The monitoring management module stores and manages the detection results and visualizes the changing trends of the detection results.

2. The pathogen carrying detection system based on deep learning according to claim 1, characterized in that: In the feature extraction module, based on the U-Net structure of Swin Transformer, a feature extraction model is constructed by combining parallel and sequential strategies. The specific implementation steps are as follows: Step S1: Data preparation: collect historical mosquito image data and mosquito molecular data to construct a dataset, which is divided into training set, validation set and test set in a ratio of 6:2:2; Step S2: Model construction: construct a feature extraction model based on the U-Net model based on Swin Transformer, including an encoder and a decoder. LoRA and Adapter modules are inserted into the encoder. The parameters of the feature extraction model are optimized by combining parallel and sequential strategies. The decoder adopts the U-Net decoder structure. Step S3: Model architecture adjustment. Using the local feature extraction capability of Swin Transformer, the image data of historical mosquitoes are divided into blocks and feature aggregated to obtain image features. An independent feature extraction module is added. The molecular data of historical mosquitoes are converted into molecular features using a multilayer perceptron. A feature fusion module is introduced into the encoder to combine the image features and molecular features of historical mosquitoes to generate a joint feature map. The decoder combines high-resolution features through skip connections to restore the joint feature map to an output feature map. Step S4: Model training, using the training set as input, generating a joint feature map through the encoder, passing it to the decoder for restoration to obtain the output feature map, setting the loss function by combining Dice loss and cross entropy loss, freezing the encoder weights at the beginning of training, and only training the LoRA and Adapter modules in parallel; Step S5: Model testing, evaluating the Dice coefficient and HD95 index of the feature extraction model on the validation set; Step S6: feature extraction application, using the trained model to extract features from the mosquito samples collected by the data collection module at the border port, and obtain an output feature map of the mosquito samples.

3. The pathogen carrying detection system based on deep learning according to claim 1, characterized in that: In the deep learning module, the deep learning module uses the jump residual method and specifically includes the following steps: Step Q1: Data input, receiving the output feature map of the mosquito sample, performing normalization processing to obtain the processed feature map, using the YOLOv8 model as the basic architecture to build a pathogen recognition model, introducing the residual learning part, feature enhancement part, conditional random field and dynamic upsampling part; Step Q2: The first residual learning, in the residual learning part, the first sub-residual block and the second sub-residual block are set, the processed feature map is input into the first sub-residual block, the first sub-residual block extracts features through the convolution layer, and calculates the residual through the jump connection to obtain the residual feature value ; Step Q3: Feature enhancement, through the feature enhancement part, a spatial attention mask is generated through 1×1 convolution and Softmax operation, and the residual eigenvalues ​​are Combined with spatial attention mask to generate feature representation ; Step Q4: Second residual learning, feature representation Input to the second sub-residual block, and obtain the residual eigenvalue through convolution operation and residual connection ; Step Q5: Fuzzy processing, in the residual eigenvalue Fuzzy processing is performed on the residual eigenvalue using Gaussian function Perform smoothing to obtain a feature map of fuzzy output; Step Q6: feature enhancement, combining the fuzzy output feature map and the output feature map of the unprocessed mosquito sample in step Q1 through residual connection to obtain a high-resolution feature map; Step Q7: Conditional random field processing, by optimizing the high-resolution feature map based on the contextual relationship between pixels; Step Q8: Dynamic upsampling: Based on step Q7, an adaptive offset is generated by static and dynamic scaling factors, and the sampling point position is dynamically adjusted by the adaptive offset to obtain the final pathogen identification map; Step Q9: Classification and recognition, build a classification model based on a deep neural network, classify the pathogen recognition map generated in step Q8, and obtain the recognition result.

4. The pathogen carrying detection system based on deep learning according to claim 3 is characterized in that: In the deep learning module, the deep learning module uses the jump residual method and specifically includes the following steps: Step Q8 specifically includes the following contents: The adaptive offset is generated by static and dynamic scaling factors: the static scaling factor is a preset fixed sampling multiple, and the dynamic scaling factor is a preset sampling point adjustment parameter; Dynamic offset calculation: Use the dynamic scaling factor to predict the offset of the sampling point, extract features through the convolution layer and combine with the Sigmoid activation function to generate the offset value of each pixel and obtain the dynamically adjusted sampling point position; Adjust the sampling point positions: Use the dynamically adjusted sampling point positions to interpolate the high-resolution feature map to obtain the final pathogen identification map.

Images