在树莓派上实现numpy的conv2d卷积神经网络做图像分类，加载pytorch的模型参数，推理mnist手写数字识别，并使用多进程加速-6ren

在树莓派上实现numpy的conv2d卷积神经网络做图像分类，加载pytorch的模型参数，推理mnist手写数字识别，并使用多进程加速

转载作者：我是一只小鸟更新时间：2023-05-30 22:31:32

这几天又在玩树莓派，先是搞了个物联网，又在尝试在树莓派上搞一些简单的神经网络，这次搞得是卷积识别mnist手写数字识别。

训练代码在电脑上，cpu就能训练，很快的:

                          
                            import
                          
                          
                             torch

                          
                          
                            import
                          
                          
                             torch.nn as nn

                          
                          
                            import
                          
                          
                             torch.optim as optim

                          
                          
                            from
                          
                           torchvision 
                          
                            import
                          
                          
                             datasets, transforms

                          
                          
                            import
                          
                          
                             numpy as np


                          
                          
                            #
                          
                          
                             设置随机种子
                          
                          
torch.manual_seed(42
                          
                            )


                          
                          
                            #
                          
                          
                             定义数据预处理
                          
                          
transform =
                          
                             transforms.Compose([
    transforms.ToTensor(),
    
                          
                          
                            #
                          
                          
                             transforms.Normalize((0.1307,), (0.3081,))
                          
                          
                            ])


                          
                          
                            #
                          
                          
                             加载训练数据集
                          
                          
train_dataset = datasets.MNIST(
                          
                            '
                          
                          
                            data
                          
                          
                            '
                          
                          , train=True, download=True, transform=
                          
                            transform)
train_loader 
                          
                          = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=
                          
                            True)


                          
                          
                            #
                          
                          
                             构建卷积神经网络模型
                          
                          
                            class
                          
                          
                             Net(nn.Module):
    
                          
                          
                            def
                          
                          
                            __init__
                          
                          
                            (self):
        super(Net, self).
                          
                          
                            __init__
                          
                          
                            ()
        self.conv1 
                          
                          = nn.Conv2d(1, 10, kernel_size=5
                          
                            )
        self.pool 
                          
                          = nn.MaxPool2d(2
                          
                            )
        self.fc 
                          
                          = nn.Linear(10 * 12 * 12, 10
                          
                            )

    
                          
                          
                            def
                          
                          
                             forward(self, x):
        x 
                          
                          =
                          
                             self.pool(torch.relu(self.conv1(x)))
        x 
                          
                          = x.view(-1, 10 * 12 * 12
                          
                            )
        x 
                          
                          =
                          
                             self.fc(x)
        
                          
                          
                            return
                          
                          
                             x

model 
                          
                          =
                          
                             Net()


                          
                          
                            #
                          
                          
                             定义损失函数和优化器
                          
                          
criterion =
                          
                             nn.CrossEntropyLoss()
optimizer 
                          
                          = optim.SGD(model.parameters(), lr=0.01, momentum=0.5
                          
                            )


                          
                          
                            #
                          
                          
                             训练模型
                          
                          
                            def
                          
                          
                             train(model, device, train_loader, optimizer, criterion, epochs):
    model.train()
    
                          
                          
                            for
                          
                           epoch 
                          
                            in
                          
                          
                             range(epochs):
        
                          
                          
                            for
                          
                           batch_idx, (data, target) 
                          
                            in
                          
                          
                             enumerate(train_loader):
            data, target 
                          
                          =
                          
                             data.to(device), target.to(device)
            optimizer.zero_grad()
            output 
                          
                          =
                          
                             model(data)
            loss 
                          
                          =
                          
                             criterion(output, target)
            loss.backward()
            optimizer.step()
            
                          
                          
                            if
                          
                           batch_idx % 100 ==
                          
                             0:
                
                          
                          
                            print
                          
                          (f
                          
                            '
                          
                          
                            Train Epoch: {epoch+1} [{batch_idx * len(data)}/{len(train_loader.dataset)} 
                          
                          
                            '
                          
                          
                            
                      f
                          
                          
                            '
                          
                          
                            ({100. * batch_idx / len(train_loader):.0f}%)]\tLoss: {loss.item():.6f}
                          
                          
                            '
                          
                          
                            )


                          
                          
                            #
                          
                          
                             在GPU上训练（如果可用），否则使用CPU
                          
                          
device = torch.device(
                          
                            "
                          
                          
                            cuda
                          
                          
                            "
                          
                          
                            if
                          
                           torch.cuda.is_available() 
                          
                            else
                          
                          
                            "
                          
                          
                            cpu
                          
                          
                            "
                          
                          
                            )
model.to(device)


                          
                          
                            #
                          
                          
                             训练模型
                          
                          
train(model, device, train_loader, optimizer, criterion, epochs=5
                          
                            )


                          
                          
                            #
                          
                          
                             保存模型为NumPy数据
                          
                          
model_state =
                          
                             model.state_dict()
numpy_model_state 
                          
                          = {key: value.cpu().numpy() 
                          
                            for
                          
                           key, value 
                          
                            in
                          
                          
                             model_state.items()}
np.savez(
                          
                          
                            '
                          
                          
                            model.npz
                          
                          
                            '
                          
                          , **
                          
                            numpy_model_state)

                          
                          
                            print
                          
                          (
                          
                            "
                          
                          
                            Model saved as model.npz
                          
                          
                            "
                          
                          )

然后需要自己在dataset里导出一些图片：我保存在了mnist_pi文件夹下,“_”后面的是标签，主要是在pc端导出保存到树莓派下。

树莓派推理端的代码，需要numpy手动重新搭建网络，并且需要手动实现conv2d卷积神经网络和maxpool2d最大池化，然后加载那些保存的矩阵参数，做矩阵乘法和加法。

                          
                            import
                          
                          
                             numpy as np

                          
                          
                            import
                          
                          
                             os

                          
                          
                            from
                          
                           PIL 
                          
                            import
                          
                          
                             Image


                          
                          
                            def
                          
                           conv2d(input, weight, bias, stride=1, padding=
                          
                            0):
    batch_size, in_channels, in_height, in_width 
                          
                          =
                          
                             input.shape
    out_channels, in_channels, kernel_size, _ 
                          
                          =
                          
                             weight.shape

    
                          
                          
                            #
                          
                          
                             计算输出特征图的大小
                          
                          
    out_height = (in_height + 2 * padding - kernel_size) // stride + 1
                          
                            
    out_width 
                          
                          = (in_width + 2 * padding - kernel_size) // stride + 1

    
                          
                            #
                          
                          
                             添加padding
                          
                          
    padded_input = np.pad(input, ((0, 0), (0, 0), (padding, padding), (padding, padding)), mode=
                          
                            '
                          
                          
                            constant
                          
                          
                            '
                          
                          
                            )

    
                          
                          
                            #
                          
                          
                             初始化输出特征图
                          
                          
    output =
                          
                             np.zeros((batch_size, out_channels, out_height, out_width))

    
                          
                          
                            #
                          
                          
                             执行卷积操作
                          
                          
                            for
                          
                           b 
                          
                            in
                          
                          
                             range(batch_size):
        
                          
                          
                            for
                          
                           c_out 
                          
                            in
                          
                          
                             range(out_channels):
            
                          
                          
                            for
                          
                           h_out 
                          
                            in
                          
                          
                             range(out_height):
                
                          
                          
                            for
                          
                           w_out 
                          
                            in
                          
                          
                             range(out_width):
                    h_start 
                          
                          = h_out *
                          
                             stride
                    h_end 
                          
                          = h_start +
                          
                             kernel_size
                    w_start 
                          
                          = w_out *
                          
                             stride
                    w_end 
                          
                          = w_start +
                          
                             kernel_size

                    
                          
                          
                            #
                          
                          
                             提取对应位置的输入图像区域
                          
                          
                    input_region =
                          
                             padded_input[b, :, h_start:h_end, w_start:w_end]

                    
                          
                          
                            #
                          
                          
                             计算卷积结果
                          
                          
                    x = input_region *
                          
                             weight[c_out]
                    bia 
                          
                          =
                          
                             bias[c_out]
                    conv_result 
                          
                          = np.sum(x, axis=(0,1, 2)) +
                          
                             bia

                    
                          
                          
                            #
                          
                          
                             将卷积结果存储到输出特征图中
                          
                          
                    output[b, c_out, h_out, w_out] =
                          
                             conv_result

    
                          
                          
                            return
                          
                          
                             output


                          
                          
                            def
                          
                           max_pool2d(input, kernel_size, stride=None, padding=
                          
                            0):
    batch_size, channels, in_height, in_width 
                          
                          =
                          
                             input.shape

    
                          
                          
                            if
                          
                           stride 
                          
                            is
                          
                          
                             None:
        stride 
                          
                          =
                          
                             kernel_size

    out_height 
                          
                          = (in_height - kernel_size + 2 * padding) // stride + 1
                          
                            
    out_width 
                          
                          = (in_width - kernel_size + 2 * padding) // stride + 1
                          
                            

    padded_input 
                          
                          = np.pad(input, ((0, 0), (0, 0), (padding, padding), (padding, padding)), mode=
                          
                            '
                          
                          
                            constant
                          
                          
                            '
                          
                          
                            )

    output 
                          
                          =
                          
                             np.zeros((batch_size, channels, out_height, out_width))

    
                          
                          
                            for
                          
                           b 
                          
                            in
                          
                          
                             range(batch_size):
        
                          
                          
                            for
                          
                           c 
                          
                            in
                          
                          
                             range(channels):
            
                          
                          
                            for
                          
                           h_out 
                          
                            in
                          
                          
                             range(out_height):
                
                          
                          
                            for
                          
                           w_out 
                          
                            in
                          
                          
                             range(out_width):
                    h_start 
                          
                          = h_out *
                          
                             stride
                    h_end 
                          
                          = h_start +
                          
                             kernel_size
                    w_start 
                          
                          = w_out *
                          
                             stride
                    w_end 
                          
                          = w_start +
                          
                             kernel_size

                    input_region 
                          
                          =
                          
                             padded_input[b, c, h_start:h_end, w_start:w_end]

                    output[b, c, h_out, w_out] 
                          
                          =
                          
                             np.max(input_region)

    
                          
                          
                            return
                          
                          
                             output



                          
                          
                            #
                          
                          
                             加载保存的模型数据
                          
                          
model_data = np.load(
                          
                            '
                          
                          
                            model.npz
                          
                          
                            '
                          
                          
                            )


                          
                          
                            #
                          
                          
                             提取模型参数
                          
                          
conv_weight = model_data[
                          
                            '
                          
                          
                            conv1.weight
                          
                          
                            '
                          
                          
                            ]
conv_bias 
                          
                          = model_data[
                          
                            '
                          
                          
                            conv1.bias
                          
                          
                            '
                          
                          
                            ]
fc_weight 
                          
                          = model_data[
                          
                            '
                          
                          
                            fc.weight
                          
                          
                            '
                          
                          
                            ]
fc_bias 
                          
                          = model_data[
                          
                            '
                          
                          
                            fc.bias
                          
                          
                            '
                          
                          
                            ]


                          
                          
                            #
                          
                          
                             进行推理
                          
                          
                            def
                          
                          
                             inference(images):
    
                          
                          
                            #
                          
                          
                             执行卷积操作
                          
                          
    conv_output = conv2d(images, conv_weight, conv_bias, stride=1, padding=
                          
                            0)
    conv_output 
                          
                          = np.maximum(conv_output, 0)  
                          
                            #
                          
                          
                             ReLU激活函数
                          
                          
                            #
                          
                          
                            maxpool2d
                          
                          
    pool = max_pool2d(conv_output,2
                          
                            )
    
                          
                          
                            #
                          
                          
                             执行全连接操作
                          
                          
    flattened = pool.reshape(pool.shape[0], -1
                          
                            )
    fc_output 
                          
                          = np.dot(flattened, fc_weight.T) +
                          
                             fc_bias
    fc_output 
                          
                          = np.maximum(fc_output, 0)  
                          
                            #
                          
                          
                             ReLU激活函数
                          
                          
                            #
                          
                          
                             获取预测结果
                          
                          
    predictions = np.argmax(fc_output, axis=1
                          
                            )

    
                          
                          
                            return
                          
                          
                             predictions


folder_path 
                          
                          = 
                          
                            '
                          
                          
                            ./mnist_pi
                          
                          
                            '
                          
                          
                            #
                          
                          
                             替换为图片所在的文件夹路径
                          
                          
                            def
                          
                          
                             infer_images_in_folder(folder_path):
    
                          
                          
                            for
                          
                           file_name 
                          
                            in
                          
                          
                             os.listdir(folder_path):
        file_path 
                          
                          =
                          
                             os.path.join(folder_path, file_name)
        
                          
                          
                            if
                          
                           os.path.isfile(file_path) 
                          
                            and
                          
                           file_name.endswith((
                          
                            '
                          
                          
                            .jpg
                          
                          
                            '
                          
                          , 
                          
                            '
                          
                          
                            .jpeg
                          
                          
                            '
                          
                          , 
                          
                            '
                          
                          
                            .png
                          
                          
                            '
                          
                          
                            )):
            image 
                          
                          =
                          
                             Image.open(file_path)
            label 
                          
                          = file_name.split(
                          
                            "
                          
                          
                            .
                          
                          
                            "
                          
                          )[0].split(
                          
                            "
                          
                          
                            _
                          
                          
                            "
                          
                          )[1
                          
                            ]
            image 
                          
                          = np.array(image)/255.0
                          
                            
            image 
                          
                          = np.expand_dims(image,axis=
                          
                            0)
            image 
                          
                          = np.expand_dims(image,axis=
                          
                            0)
            
                          
                          
                            print
                          
                          (
                          
                            "
                          
                          
                            file_path:
                          
                          
                            "
                          
                          ,file_path,
                          
                            "
                          
                          
                            img size:
                          
                          
                            "
                          
                          ,image.shape,
                          
                            "
                          
                          
                            label:
                          
                          
                            "
                          
                          
                            ,label)
            predicted_class 
                          
                          =
                          
                             inference(image)
            
                          
                          
                            print
                          
                          (
                          
                            '
                          
                          
                            Predicted class:
                          
                          
                            '
                          
                          
                            , predicted_class)

infer_images_in_folder(folder_path)

。

这代码完全就是numpy推理，不需要安装pytorch，树莓派也装不动pytorch，太重了，下面是推理结果，比之前的MLP网络慢很多，主要是手动实现的卷积网络全靠循环实现.

那我们给它加加速吧，下面是一个多线程加速程序:

                          
                            import
                          
                          
                             numpy as np

                          
                          
                            import
                          
                          
                             os

                          
                          
                            from
                          
                           PIL 
                          
                            import
                          
                          
                             Image

                          
                          
                            from
                          
                           multiprocessing 
                          
                            import
                          
                          
                             Pool


                          
                          
                            def
                          
                           conv2d(input, weight, bias, stride=1, padding=
                          
                            0):
    batch_size, in_channels, in_height, in_width 
                          
                          =
                          
                             input.shape
    out_channels, in_channels, kernel_size, _ 
                          
                          =
                          
                             weight.shape

    
                          
                          
                            #
                          
                          
                             计算输出特征图的大小
                          
                          
    out_height = (in_height + 2 * padding - kernel_size) // stride + 1
                          
                            
    out_width 
                          
                          = (in_width + 2 * padding - kernel_size) // stride + 1

    
                          
                            #
                          
                          
                             添加padding
                          
                          
    padded_input = np.pad(input, ((0, 0), (0, 0), (padding, padding), (padding, padding)), mode=
                          
                            '
                          
                          
                            constant
                          
                          
                            '
                          
                          
                            )

    
                          
                          
                            #
                          
                          
                             初始化输出特征图
                          
                          
    output =
                          
                             np.zeros((batch_size, out_channels, out_height, out_width))

    
                          
                          
                            #
                          
                          
                             执行卷积操作
                          
                          
                            for
                          
                           b 
                          
                            in
                          
                          
                             range(batch_size):
        
                          
                          
                            for
                          
                           c_out 
                          
                            in
                          
                          
                             range(out_channels):
            
                          
                          
                            for
                          
                           h_out 
                          
                            in
                          
                          
                             range(out_height):
                
                          
                          
                            for
                          
                           w_out 
                          
                            in
                          
                          
                             range(out_width):
                    h_start 
                          
                          = h_out *
                          
                             stride
                    h_end 
                          
                          = h_start +
                          
                             kernel_size
                    w_start 
                          
                          = w_out *
                          
                             stride
                    w_end 
                          
                          = w_start +
                          
                             kernel_size

                    
                          
                          
                            #
                          
                          
                             提取对应位置的输入图像区域
                          
                          
                    input_region =
                          
                             padded_input[b, :, h_start:h_end, w_start:w_end]

                    
                          
                          
                            #
                          
                          
                             计算卷积结果
                          
                          
                    x = input_region *
                          
                             weight[c_out]
                    bia 
                          
                          =
                          
                             bias[c_out]
                    conv_result 
                          
                          = np.sum(x, axis=(0,1, 2)) +
                          
                             bia

                    
                          
                          
                            #
                          
                          
                             将卷积结果存储到输出特征图中
                          
                          
                    output[b, c_out, h_out, w_out] =
                          
                             conv_result

    
                          
                          
                            return
                          
                          
                             output


                          
                          
                            def
                          
                           max_pool2d(input, kernel_size, stride=None, padding=
                          
                            0):
    batch_size, channels, in_height, in_width 
                          
                          =
                          
                             input.shape

    
                          
                          
                            if
                          
                           stride 
                          
                            is
                          
                          
                             None:
        stride 
                          
                          =
                          
                             kernel_size

    out_height 
                          
                          = (in_height - kernel_size + 2 * padding) // stride + 1
                          
                            
    out_width 
                          
                          = (in_width - kernel_size + 2 * padding) // stride + 1
                          
                            

    padded_input 
                          
                          = np.pad(input, ((0, 0), (0, 0), (padding, padding), (padding, padding)), mode=
                          
                            '
                          
                          
                            constant
                          
                          
                            '
                          
                          
                            )

    output 
                          
                          =
                          
                             np.zeros((batch_size, channels, out_height, out_width))

    
                          
                          
                            for
                          
                           b 
                          
                            in
                          
                          
                             range(batch_size):
        
                          
                          
                            for
                          
                           c 
                          
                            in
                          
                          
                             range(channels):
            
                          
                          
                            for
                          
                           h_out 
                          
                            in
                          
                          
                             range(out_height):
                
                          
                          
                            for
                          
                           w_out 
                          
                            in
                          
                          
                             range(out_width):
                    h_start 
                          
                          = h_out *
                          
                             stride
                    h_end 
                          
                          = h_start +
                          
                             kernel_size
                    w_start 
                          
                          = w_out *
                          
                             stride
                    w_end 
                          
                          = w_start +
                          
                             kernel_size

                    input_region 
                          
                          =
                          
                             padded_input[b, c, h_start:h_end, w_start:w_end]

                    output[b, c, h_out, w_out] 
                          
                          =
                          
                             np.max(input_region)

    
                          
                          
                            return
                          
                          
                             output


                          
                          
                            #
                          
                          
                             加载保存的模型数据
                          
                          
model_data = np.load(
                          
                            '
                          
                          
                            model.npz
                          
                          
                            '
                          
                          
                            )


                          
                          
                            #
                          
                          
                             提取模型参数
                          
                          
conv_weight = model_data[
                          
                            '
                          
                          
                            conv1.weight
                          
                          
                            '
                          
                          
                            ]
conv_bias 
                          
                          = model_data[
                          
                            '
                          
                          
                            conv1.bias
                          
                          
                            '
                          
                          
                            ]
fc_weight 
                          
                          = model_data[
                          
                            '
                          
                          
                            fc.weight
                          
                          
                            '
                          
                          
                            ]
fc_bias 
                          
                          = model_data[
                          
                            '
                          
                          
                            fc.bias
                          
                          
                            '
                          
                          
                            ]


                          
                          
                            #
                          
                          
                             进行推理
                          
                          
                            def
                          
                          
                             inference(images):
    
                          
                          
                            #
                          
                          
                             执行卷积操作
                          
                          
    conv_output = conv2d(images, conv_weight, conv_bias, stride=1, padding=
                          
                            0)
    conv_output 
                          
                          = np.maximum(conv_output, 0)  
                          
                            #
                          
                          
                             ReLU激活函数
                          
                          
                            #
                          
                          
                             maxpool2d
                          
                          
    pool = max_pool2d(conv_output, 2
                          
                            )
    
                          
                          
                            #
                          
                          
                             执行全连接操作
                          
                          
    flattened = pool.reshape(pool.shape[0], -1
                          
                            )
    fc_output 
                          
                          = np.dot(flattened, fc_weight.T) +
                          
                             fc_bias
    fc_output 
                          
                          = np.maximum(fc_output, 0)  
                          
                            #
                          
                          
                             ReLU激活函数
                          
                          
                            #
                          
                          
                             获取预测结果
                          
                          
    predictions = np.argmax(fc_output, axis=1
                          
                            )

    
                          
                          
                            return
                          
                          
                             predictions

labels 
                          
                          =
                          
                             []
preds 
                          
                          =
                          
                             []

                          
                          
                            def
                          
                          
                             infer_image(file_path):
    image 
                          
                          =
                          
                             Image.open(file_path)
    label 
                          
                          = file_path.split(
                          
                            "
                          
                          
                            /
                          
                          
                            "
                          
                          )[-1].split(
                          
                            "
                          
                          
                            .
                          
                          
                            "
                          
                          )[0].split(
                          
                            "
                          
                          
                            _
                          
                          
                            "
                          
                          )[1
                          
                            ]
    image 
                          
                          = np.array(image) / 255.0
                          
                            
    image 
                          
                          = np.expand_dims(image, axis=
                          
                            0)
    image 
                          
                          = np.expand_dims(image, axis=
                          
                            0)
    
                          
                          
                            print
                          
                          (
                          
                            "
                          
                          
                            file_path:
                          
                          
                            "
                          
                          , file_path, 
                          
                            "
                          
                          
                            img size:
                          
                          
                            "
                          
                          , image.shape, 
                          
                            "
                          
                          
                            label:
                          
                          
                            "
                          
                          
                            , label)
    predicted_class 
                          
                          =
                          
                             inference(image)
    
                          
                          
                            print
                          
                          (
                          
                            '
                          
                          
                            Predicted class:
                          
                          
                            '
                          
                          
                            , predicted_class)


folder_path 
                          
                          = 
                          
                            '
                          
                          
                            ./mnist_pi
                          
                          
                            '
                          
                          
                            #
                          
                          
                             替换为图片所在的文件夹路径
                          
                          
pool = Pool(processes=4)  
                          
                            #
                          
                          
                             设置进程数为2，可以根据需要进行调整
                          
                          
                            def
                          
                          
                             infer_images_in_folder(folder_path):
    
                          
                          
                            for
                          
                           file_name 
                          
                            in
                          
                          
                             os.listdir(folder_path):
        file_path 
                          
                          =
                          
                             os.path.join(folder_path, file_name)
        
                          
                          
                            if
                          
                           os.path.isfile(file_path) 
                          
                            and
                          
                           file_name.endswith((
                          
                            '
                          
                          
                            .jpg
                          
                          
                            '
                          
                          , 
                          
                            '
                          
                          
                            .jpeg
                          
                          
                            '
                          
                          , 
                          
                            '
                          
                          
                            .png
                          
                          
                            '
                          
                          
                            )):
            pool.apply_async(infer_image, args
                          
                          =
                          
                            (file_path,))

    pool.close()
    pool.join()


infer_images_in_folder(folder_path)

。

下图可以看出来，我的树莓派3b+，cpu直接拉满，速度提升4倍:

。

最后此篇关于在树莓派上实现numpy的conv2d卷积神经网络做图像分类，加载pytorch的模型参数，推理mnist手写数字识别，并使用多进程加速的文章就讲到这里了,如果你想了解更多关于在树莓派上实现numpy的conv2d卷积神经网络做图像分类，加载pytorch的模型参数，推理mnist手写数字识别，并使用多进程加速的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。

文章推荐： AntVL7快速入门示例

文章推荐：简单了解一下国产CPU

文章推荐： Python连接es笔记三之es更新操作

文章推荐： Doris(五)--数据的导入导出

android - java.lang.ClassNotFoundException : android. 网络.网络
这与 Payubiz payment gateway sdk 关系不大一体化。但是，主要问题与构建项目有关。每当我们尝试在模拟器上运行应用程序时。我们得到以下失败: What went wrong:
Docker 链接容器、Docker 网络、Compose 网络 - 我们现在应该如何 'link' 容器
我有一个现有的应用程序，其中包含在同一主机上运行的 4 个 docker 容器。它们已使用 link 命令链接在一起。然而，在 docker 升级后，link 行为已被弃用，并且似乎有所改变。我们现
网络:传输层和网络层之间的区别
在 Internet 模型中有四层:链路 -> 网络 -> 传输 -> 应用程序。我真的不知道网络层和传输层之间的区别。当我读到: Transport layer: include congesti
python ，网络
很难说出这里要问什么。这个问题模棱两可、含糊不清、不完整、过于宽泛或夸夸其谈，无法以目前的形式得到合理的回答。如需帮助澄清此问题以便重新打开，visit the help center . 关闭 1
初始 http【网络】
前言：生活中，我们在上网时，打开一个网页，就可以看到网址，如下： https😕/xhuahua.blog.csdn.net/ 访问网站使用的协议类型：https(基于 http 实现的，只不过在
171、HBase性能调整：网络
网络避免网络问题降低Hadoop和HBase性能的最重要因素可能是所使用的交换硬件，在项目范围的早期做出的决策可能会导致群集大小增加一倍或三倍（或更多）时出现重大问题。需要考虑的重要事项：
189、故障排除和调试HBase：网络
网络网络峰值如果您看到定期的网络峰值，您可能需要检查compactionQueues以查看主要压缩是否正在发生。有关管理压缩的更多信息，请参阅管理压缩部分的内容。 Loopback IP
NoFlo - 如何启动图形/网络
Pure Data 有一个 loadbang 组件，它按照它说的做:当图形开始运行时发送一个 bang。 NoFlo 的 core/Kick 在其 IN 输入被击中之前不会发送其数据，并且您无法在 n
kubernetes - Minikube 网络
我有一台 Linux 构建机器，我也安装了 minikube。在 minikube 实例中，我安装了 artifactory，我将使用它来存储各种构建工件我现在希望能够在我的开发机器上做一些工作(这
http - 我需要多少种视频格式？ - 网络
我想知道每个视频需要多少种不同的格式才能支持所有主要设备？在我考虑的主要设备中:安卓手机 + iPhone + iPad . 对具有不同比特率的视频进行编码也是一种好习惯吗？那里有太多相互矛盾的信
Flutter 网络 flavor
我有一个使用 firebase 的 Flutter Web 应用程序，我有两个 firebase 项目(dev 和 prod)。我想为这个项目设置 Flavors(只是网络没有移动)。在移动端，我
passwords - 传输前对密码进行哈希处理？ (网络)
我正在读这篇文章Ars article关于密码安全，它提到有一些网站“在传输之前对密码进行哈希处理”？现在，假设这不使用 SSL 连接 (HTTPS)，a.这真的安全吗？ b．如果是的话，你会如何在
networking - docker 网络
我试图了解以下之间的关系: eth0在主机上；和 docker0桥;和 eth0每个容器上的接口(interface) 据我了解，Docker: 创建一个 docker0桥接，然后为其分配一个与主机上
java - 不可序列化对象 - 网络
我需要编写一个java程序，通过网络将对象发送到客户端程序。问题是一些需要发送的对象是不可序列化的。如何最好地解决这个问题？最佳答案发送在客户端重建对象所需的数据。关于java - 不可序列化对
Java 网络，不仅仅是简单的聊天室
所以我最近关注了this有关用 Java 制作基本聊天室的教程。它使用多线程，是一个“面向连接”的服务器。我想知道如何使用相同的 Sockets 和 ServerSockets 来发送对象的 3d 位
java图像接收(网络)服务器
我想制作一个系统，其中java客户端程序将图像发送到中央服务器。中央服务器保存它们并运行使用这些图像的网站。我应该如何发送图像以及如何接收它们？我可以使用同一个网络服务器来接收和显示网站吗？最佳答
email - 网络::SMTPAuthenticationError
我正在尝试设置我的 rails 4 应用程序，以便它发送电子邮件。有谁知道我为什么会得到: Net::SMTPAuthenticationError 534-5.7.9 Application-spe
Java 网络 - 连接两台计算机
我正在尝试编写一个简单的客户端-服务器程序，它将客户端计算机连接到服务器计算机。到目前为止，我的代码在本地主机上运行良好，但是当我将客户端代码中的 IP 地址替换为服务器计算机的本地 IP 地址时，
Java 网络 - 在同一线程中的不同端口上并行启动多个服务器套接字
我需要在服务器上并行启动多个端口，并且所有服务器套接字都应在 socket.accept() 上阻塞。同一个线程需要启动客户端套接字(许多)来连接到特定的 ServerSocket。这能实现吗？
java - 网络/数据库作业的足够线程数
我的工作执行了大约 10000 次以下任务: 1) HTTP 请求(1 秒) 2)数据转换(0.3秒) 3)数据库插入(0.7秒) 每次迭代的总时间约为 2 秒，分布如上所述。我想做多任务处理，但我

我是一只小鸟

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

在树莓派上实现numpy的conv2d卷积神经网络做图像分类，加载pytorch的模型参数，推理mnist手写数字识别，并使用多进程加速