Pathogen Carrier Detection System Based on Deep Learning

Abstract

The present invention relates to the field of public health, specifically to a deep learning-based pathogen detection system, comprising a data acquisition module, a feature extraction module, a deep learning module, a pathogen detection module, and a monitoring and management module. This solution introduces a Swin Transformer-based U-Net structure into the feature extraction module, combining parallel and sequential strategies to construct a feature extraction model. Residual learning, dynamic upsampling, and conditional random field processing are used to reduce noise interference during the detection process. A jump residual method is used in the deep learning module to classify and identify output feature images. This method combines the YOLOv8 infrastructure with the jump residual method, reduces noise interference in feature maps through fuzzy processing, and further optimizes pixel context relationships using conditional random fields. This significantly improves detection accuracy, robustness, and efficiency.

Description

Technical Field

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

[0002] With the increasing frequency of public health incidents in recent years, pathogen detection technology based on deep learning has gradually become an important direction in medical research. Existing pathogen detection systems often suffer from low detection accuracy. This is due to biased collection of pathogen images, which results in the loss of detailed image features. Furthermore, the detection process is susceptible to interference from image noise or molecular data, leading to erroneous results. Summary of the Invention

[0003] In response to the above situation, in order to overcome the defects of the existing technology, the present invention provides a pathogen carrying detection system based on deep learning. In view of the problem of low detection accuracy in most existing pathogen carrying detection systems, the present invention introduces a U-Net structure based on Swin Transformer in the feature extraction module, and combines parallel and sequential strategies to construct a feature extraction model. The local attention mechanism of Swin Transformer captures the fine-grained features of the image, and the jump connection of U-Net retains 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 clearer pathogen identification results are output; the present invention uses a jump residual method in the deep learning module to classify and identify the output feature image, and combines the basic architecture based on YOLOv8 with the jump residual method to improve the feature extraction and classification efficiency. Through the jump residual method, multi-layer feature extraction is introduced, and key information is retained in each residual learning process, which alleviates the problems of gradient vanishing and overfitting, significantly improving the detection accuracy. At the same time, the noise interference of the feature map is reduced by fuzzy processing, and the conditional random field further optimizes the pixel context relationship. It significantly improves the accuracy, robustness and efficiency of detection, and enhances the applicability and reliability of the system, meeting the high standards for pathogen detection in the field of modern public health.

[0004] The technical solution adopted by the present invention is as follows: The pathogen detection system based on deep learning provided by the present invention is mainly used to detect pathogens carried by mosquitoes at border ports. It includes 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 contents:

[0005] The data acquisition 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;

[0006] The feature extraction module is based on the U-Net structure of Swin Transformer, combines 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;

[0007] The deep learning module uses the YOLOv8-based infrastructure and the skip residual method to classify and recognize the output feature image to obtain the recognition result;

[0008] 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;

[0009] The monitoring management module stores and manages the detection results and visualizes the changing trends 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 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 training set, validation set and test set in a ratio of 6:2:2;

[0012] Step S2: Model construction: A feature extraction model is constructed based on the U-Net model based on the Swin Transformer, including an encoder and a decoder. The LoRA and Adapter modules are inserted into the encoder, and the parameters of the feature extraction model are optimized using a combination of parallel and sequential strategies. The decoder adopts the U-Net decoder structure.

[0013] Step S3: Model architecture adjustment. Using the local feature extraction capability of the Swin Transformer, the historical mosquito image data is segmented and feature aggregated to obtain image features. An independent feature extraction module is added. The molecular data of the historical mosquitoes is 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 the historical mosquitoes to generate a joint feature map. The decoder combines high-resolution features through skip connections and restores the joint feature map to the output feature map.

[0014] Step S4: Model training, using the training set as input, generates a joint feature map through the encoder, passes it to the decoder for restoration to obtain the output feature map, and sets the loss function by combining Dice loss and cross entropy loss. At the beginning of training, the weights of the encoder are frozen, and only the LoRA and Adapter modules are trained in parallel;

[0015] Step S5: Model testing, evaluating the Dice coefficient and HD95 index 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 collection module at the border port, and obtain an output feature map of the mosquito samples.

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

[0018] Step Q1: Data input, receiving the output feature map of the mosquito sample, normalizing it to obtain the processed feature map, and using the YOLOv8 model as the infrastructure to build a pathogen recognition model, introducing the residual learning part, feature enhancement part, conditional random field, and dynamic upsampling part;

[0019] Step Q2: The first residual learning is performed. The first sub-residual block and the second sub-residual block are set in the residual learning part. 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 eigenvalue. ;

[0020] Step Q3: Feature enhancement, through the feature enhancement part, a spatial attention mask is generated by 1×1 convolution and Softmax operation, and the residual eigenvalues ​​are Combined with spatial attention mask to generate feature representation ;

[0021] 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 ;

[0022] Step Q5: Fuzzy processing, in the residual eigenvalue Fuzzy processing is performed on the residual eigenvalue using Gaussian function Perform smoothing to obtain the feature map of the fuzzy output;

[0023] Step Q6: Feature enhancement, combining the blurred 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;

[0024] Step Q7: Conditional Random Field processing, which optimizes the high-resolution feature map based on the contextual relationship between pixels;

[0025] Step Q8: Dynamic upsampling: Based on step Q7, an adaptive offset is generated by using static and dynamic scaling factors. The sampling point positions are dynamically adjusted by the adaptive offset to obtain the final pathogen identification map.

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

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

[0028] Generate adaptive offsets 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 convolution layer and combine it with the Sigmoid activation function to generate the offset value of each pixel and obtain the dynamically adjusted sampling point position;

[0030] 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.

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

[0032] (1) In view of the above situation, in order to overcome the defects of the existing technology, the present invention provides a pathogen carrying detection system based on deep learning. In view of the problem that most existing pathogen carrying detection systems have low detection accuracy, the present invention introduces a U-Net structure based on Swin Transformer in the feature extraction module, and combines the combination of parallel and sequential strategies to construct a feature extraction model. The local attention mechanism of Swin Transformer captures the fine-grained features of the image, and the jump connection of U-Net retains 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) This invention uses the skip residual method in the deep learning module to classify and identify the output feature image. Based on the YOLOv8 infrastructure and the skip residual method, the efficiency of feature extraction and classification is improved. The skip residual method introduces multi-layer feature extraction and retains key information in each residual learning process, alleviating the gradient vanishing and overfitting problems, significantly improving detection accuracy. At the same time, the noise interference of the feature map is reduced through fuzzy processing, and the conditional random field further optimizes the pixel context relationship. This significantly improves the accuracy, robustness and efficiency of detection, and 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 Schematic diagram of the pathogen detection system based on deep learning proposed in this invention.

[0035] The accompanying drawings are used to provide further understanding of the present invention and constitute a part of the specification. They are used to explain the present invention together with the embodiments of the present invention and do not constitute a limitation of the present invention. DETAILED DESCRIPTION

[0036] The technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only 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 ordinary technicians in this field without making creative work are within the scope of protection of the present invention.

[0037] Example 1, see Figure 1 The technical solution adopted by the present invention is as follows: The pathogen detection system based on deep learning provided by the present invention is mainly used to detect pathogens carried by mosquitoes at border ports. It includes 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 contents:

[0038] The data acquisition 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;

[0039] The feature extraction module is based on the U-Net structure of Swin Transformer, combines 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;

[0040] The deep learning module performs classification and recognition based on the YOLOv8 infrastructure and the jump residual method to obtain recognition results;

[0041] 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;

[0042] The monitoring management module stores and manages the detection results and visualizes the changing trends of the detection results.

[0043] Example 2: This example is based on the above example. In the feature extraction module, a feature extraction model is constructed based on the U-Net structure of the Swin Transformer, combined with a combination of 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 training set, validation set and test set in a ratio of 6:2:2;

[0045] Step S2: Model construction: A feature extraction model is constructed based on the U-Net model based on the Swin Transformer, including an encoder and a decoder. The LoRA and Adapter modules are inserted into the encoder, and the parameters of the feature extraction model are optimized using a combination of parallel and sequential strategies. The decoder adopts the U-Net decoder structure.

[0046] Step S3: Model architecture adjustment. Using the local feature extraction capability of the Swin Transformer, the historical mosquito image data is segmented and feature aggregated to obtain image features. An independent feature extraction module is added. The molecular data of the historical mosquitoes is 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 the historical mosquitoes to generate a joint feature map. The decoder combines high-resolution features through skip connections and restores the joint feature map to the output feature map.

[0047] Step S4: Model training, using the training set as input, generates a joint feature map through the encoder, passes it to the decoder for restoration to obtain the output feature map, and sets the loss function by combining Dice loss and cross entropy loss. At the beginning of training, the weights of the encoder are frozen, and only the LoRA and Adapter modules are trained in parallel;

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

[0049] 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.

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

[0051] In step S2, the encoder part uses the Swin Transformer to extract local features of the image data with a block size of 4×4 and a stride of 4. The LoRA module and the Adapter module are inserted at each level to reduce the number of model parameters and improve training efficiency.

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

[0053] Example 3: Based on the above example, this example uses the YOLOv8 infrastructure and the skip residual method to perform classification and recognition in a deep learning module, specifically including the following steps:

[0054] Step Q1: Data input, receiving the output feature map of the mosquito sample, normalizing it to obtain the processed feature map, and using the YOLOv8 model as the infrastructure to build a pathogen recognition model, introducing the residual learning part, feature enhancement part, conditional random field, and dynamic upsampling part;

[0055] Step Q2: The first residual learning is performed. The first sub-residual block and the second sub-residual block are set in the residual learning part. 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 eigenvalue. ;

[0056] Step Q3: Feature enhancement, through the feature enhancement part, a spatial attention mask is generated by 1×1 convolution and Softmax operation, and the residual eigenvalues ​​are Combined with spatial attention mask to generate feature representation ;

[0057] 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 ;

[0058] Step Q5: Fuzzy processing, in the residual eigenvalue Fuzzy processing is performed on the residual eigenvalue using Gaussian function Perform smoothing to obtain the feature map of the fuzzy output;

[0059] Step Q6: Feature enhancement, combining the blurred 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;

[0060] Step Q7: Conditional Random Field processing, which optimizes the high-resolution feature map based on the contextual relationship between pixels;

[0061] Step Q8: Dynamic upsampling: Based on step Q7, an adaptive offset is generated by using static and dynamic scaling factors. The sampling point positions are dynamically adjusted by the adaptive offset to obtain the final pathogen identification map.

[0062] Step Q9: Classification and recognition: construct a classification model based on a deep neural network, classify the pathogen identification map generated in step Q8, and obtain the identification 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 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 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 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 operation and adaptive offset

[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(​​​​​​​​​​​​​​​​​​​​​​​​​​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 loader and training process

[0154] if __name__ == "__main__":

[0155] # Set up the device

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

[0157] # Simulated dataset (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 rounds

[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] Embodiment 4: This embodiment is based on the above embodiment, and step Q8 specifically includes the following contents:

[0170] Generate adaptive offsets 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 point, extract features through the convolution layer and combine it with the Sigmoid activation function to generate the offset value of each pixel and obtain the dynamically adjusted sampling point position;

[0172] 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.

[0173] It should be noted that, in this document, relational terms such as first and second, etc., are used only 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 "comprises," "comprising," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that includes a list of elements includes not only those elements but also other elements not explicitly listed, or elements inherent to such process, method, article, or apparatus.

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

[0175] The present invention and its embodiments are described above. This description is not restrictive. The drawings show only one embodiment of the present invention, and the actual structure is not limited thereto. In short, if a person skilled in the art is inspired by this and, without departing from the purpose of the present invention, designs structures and embodiments similar to this technical solution without inventiveness, they shall fall within the scope of protection of the present invention.

Claims

1. A deep learning-based pathogen detection system, characterized by: It includes data acquisition module, feature extraction module, deep learning module, pathogen detection module and monitoring management module, specifically including the following contents: The data acquisition 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 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 and management module stores and manages the test results and visualizes the changing trends of the test results; 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 and merge them 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: A feature extraction model is constructed based on the U-Net model based on the Swin Transformer, including an encoder and a decoder. The LoRA and Adapter modules are inserted into the encoder, and the parameters of the feature extraction model are optimized using a combination of parallel and sequential strategies. The decoder adopts the U-Net decoder structure. Step S3: Model architecture adjustment. Using the local feature extraction capability of the Swin Transformer, the historical mosquito image data is segmented and feature aggregated to obtain image features. An independent feature extraction module is added. The molecular data of the historical mosquitoes is 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 the historical mosquitoes to generate a joint feature map. The decoder combines high-resolution features through skip connections and restores the joint feature map to the output feature map. Step S4: Model training, using the training set as input, generates a joint feature map through the encoder, passes it to the decoder for restoration to obtain the output feature map, and sets the loss function by combining Dice loss and cross entropy loss. At the beginning of training, the weights of the encoder are frozen, and only the LoRA and Adapter modules are trained 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.

2. The deep learning-based pathogen detection system 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, normalizing it to obtain the processed feature map, and using the YOLOv8 model as the infrastructure 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 is performed. The first sub-residual block and the second sub-residual block are set in the residual learning part. 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 eigenvalue. ; Step Q3: Feature enhancement, through the feature enhancement part, a spatial attention mask is generated by 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 the feature map of the fuzzy output; Step Q6: Feature enhancement, combining the blurred 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, which optimizes 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 using static and dynamic scaling factors. The sampling point positions are dynamically adjusted by the adaptive offset to obtain the final pathogen identification map. Step Q9: Classification and recognition: construct a classification model based on a deep neural network, classify the pathogen identification map generated in step Q8, and obtain the identification result.

3. The deep learning-based pathogen detection system according to claim 2, characterized in that: In the deep learning module, step Q8 specifically includes the following: Generate adaptive offsets 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; Dynamic offset calculation: Use the dynamic scaling factor to predict the offset of the sampling point, extract features through the convolution layer and combine it 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