源码解读——SplitFed: When Federated Learning Meets Split Learning

源码地址

1. 源码概述

源码里一共包含了5个py文件

  • 单机模型（Normal_ResNet_HAM10000.py）
  • 联邦模型（FL_ResNet_HAM10000.py）
  • 本地模拟的SFLV1（SFLV1_ResNet_HAM10000.py）
  • 网络socket下的SFLV2（SFLV2_ResNet_HAM10000.py）
  • 使用了DP+PixelDP隐私技术（SL_ResNet_HAM10000.py）

使用的数据集是:HAM10000 数据集是常见色素性皮肤病变的多源皮肤图像大集合。
做的是图像分类的工作。

2. Normal_ResNet_HAM10000.py

这是一个基础模型，可以在单机上进行训练和验证（有点基础的同学应该都可以看懂）。让我们来分析一下这个文件中一些主要类和方法:

2.1 SkinData(Dataset)

自定义的数据集，继承自Dataset，主要实现

class SkinData(Dataset):def __init__(self, df, transform = None):self.df = dfself.transform = transformdef __len__(self):return len(self.df)def __getitem__(self, index):X = Image.open(self.df['path'][index]).resize((64, 64))y = torch.tensor(int(self.df['target'][index]))// 进行数据增强if self.transform:X = self.transform(X)return X, y

2.2 ResNet18模型

def conv3x3(in_planes, out_planes, stride=1):"3x3 convolution with padding"return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,padding=1, bias=False)class BasicBlock(nn.Module):expansion = 1def __init__(self, inplanes, planes, stride=1, downsample=None):super(BasicBlock, self).__init__()self.conv1 = conv3x3(inplanes, planes, stride)self.bn1 = nn.BatchNorm2d(planes)self.relu = nn.ReLU(inplace=True)self.conv2 = conv3x3(planes, planes)self.bn2 = nn.BatchNorm2d(planes)self.downsample = downsampleself.stride = stridedef forward(self, x):residual = xout = self.conv1(x)out = self.bn1(out)out = self.relu(out)out = self.conv2(out)out = self.bn2(out)if self.downsample is not None:residual = self.downsample(x)out += residualout = self.relu(out)return outclass ResNet18(nn.Module):def __init__(self, block, layers, num_classes=1000):self.inplanes = 64super(ResNet18, self).__init__()self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,bias=False)self.bn1 = nn.BatchNorm2d(64)self.relu = nn.ReLU(inplace=True)self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)self.layer1 = self._make_layer(block, 64, layers[0])self.layer2 = self._make_layer(block, 128, layers[1], stride=2)self.layer3 = self._make_layer(block, 256, layers[2], stride=2)self.layer4 = self._make_layer(block, 512, layers[3], stride=2)self.avgpool = nn.AvgPool2d(7)self.fc = nn.Linear(512 * block.expansion, num_classes)for m in self.modules():if isinstance(m, nn.Conv2d):n = m.kernel_size[0] * m.kernel_size[1] * m.out_channelsm.weight.data.normal_(0, math.sqrt(2. / n))elif isinstance(m, nn.BatchNorm2d):m.weight.data.fill_(1)m.bias.data.zero_()def _make_layer(self, block, planes, blocks, stride=1):downsample = Noneif stride != 1 or self.inplanes != planes * block.expansion:downsample = nn.Sequential(nn.Conv2d(self.inplanes, planes * block.expansion,kernel_size=1, stride=stride, bias=False),nn.BatchNorm2d(planes * block.expansion),)layers = []layers.append(block(self.inplanes, planes, stride, downsample))self.inplanes = planes * block.expansionfor i in range(1, blocks):layers.append(block(self.inplanes, planes))return nn.Sequential(*layers)def forward(self, x):x = self.conv1(x)x = self.bn1(x)x = self.relu(x)x = self.maxpool(x)x = self.layer1(x)x = self.layer2(x)x = self.layer3(x)x = self.layer4(x)x = self.avgpool(x)x = x.view(x.size(0), -1)x = self.fc(x)return x

2.3 训练+验证

def calculate_accuracy(fx, y):preds = fx.max(1, keepdim=True)[1]correct = preds.eq(y.view_as(preds)).sum()acc = correct.float()/preds.shape[0]return acc#==========================================================================================================================     
def train(model, device, iterator, optimizer, criterion):epoch_loss = 0epoch_acc = 0model.train()ell = len(iterator)for (x, y) in iterator:x = x.to(device)y = y.to(device)optimizer.zero_grad() # initialize gradients to zero# ------------- Forward propagation ----------fx = model(x)loss = criterion(fx, y)acc = calculate_accuracy (fx , y)# -------- Backward propagation -----------loss.backward()optimizer.step()epoch_loss += loss.item()epoch_acc += acc.item()return epoch_loss / ell, epoch_acc / elldef evaluate(model, device, iterator, criterion):epoch_loss = 0epoch_acc = 0model.eval()ell = len(iterator)with torch.no_grad():for (x,y) in iterator:x = x.to(device)y = y.to(device)optimizer.zero_grad()fx = model(x)       loss = criterion(fx, y)acc = calculate_accuracy (fx , y)epoch_loss += loss.item()epoch_acc += acc.item()return epoch_loss/ell, epoch_acc/ell

2.4 组合代码进行训练

epochs = 200	#迭代次数
LEARNING_RATE = 0.0001		#学习率
criterion = nn.CrossEntropyLoss()		#损失函数
optimizer = torch.optim.Adam(net_glob.parameters(), lr = LEARNING_RATE)		#优化器loss_train_collect = []
loss_test_collect = []
acc_train_collect = []
acc_test_collect = []start_time = time.time()    
for epoch in range(epochs):train_loss, train_acc = train(net_glob, device, train_iterator, optimizer, criterion)		#训练test_loss, test_acc = evaluate(net_glob, device, test_iterator, criterion)	#验证loss_train_collect.append(train_loss)		loss_test_collect.append(test_loss)acc_train_collect.append(train_acc)acc_test_collect.append(test_acc)prRed(f'Train => Epoch: {epoch} \t Acc: {train_acc*100:05.2f}% \t Loss: {train_loss:.3f}')prGreen(f'Test =>               \t Acc: {test_acc*100:05.2f}% \t Loss: {test_loss:.3f}')elapsed = (time.time() - start_time)/60
print(f'Total Training Time: {elapsed:.2f} min')

3. FL_ResNet_HAM10000.py

接下来来解读这个文件：这个文件是一个本地模拟联邦的文件。模型大体上的代码是差不多的，让我们来看一下差异之处。

3.1 DatasetSplit

这是一个数据集，使用idxs来切分不同的数据。

class DatasetSplit(Dataset):def __init__(self, dataset, idxs):self.dataset = datasetself.idxs = list(idxs)def __len__(self):# 数据的长度是idx列表的长度return len(self.idxs)def __getitem__(self, item):image, label = self.dataset[self.idxs[item]]return image, label

3.2 LocalUpdate

与训练和测试有关的客户端功能

class LocalUpdate(object):def __init__(self, idx, lr, device, dataset_train = None, dataset_test = None, idxs = None, idxs_test = None):self.idx = idx  #本地客户端编号self.device = deviceself.lr = lrself.local_ep = 1self.loss_func = nn.CrossEntropyLoss()self.selected_clients = []self.ldr_train = DataLoader(DatasetSplit(dataset_train, idxs), batch_size = 256, shuffle = True)self.ldr_test = DataLoader(DatasetSplit(dataset_test, idxs_test), batch_size = 256, shuffle = True)def train(self, net):net.train()......return net.state_dict(), sum(epoch_loss) / len(epoch_loss), sum(epoch_acc) / len(epoch_acc)def evaluate(self, net):net.eval().....return sum(epoch_loss) / len(epoch_loss), sum(epoch_acc) / len(epoch_acc)

如何生成对应的数据集的idx，即如何模拟各个客户端拥有一部分数据，通过dataset_iid(dataset_train, num_users)这个函数完成。

def dataset_iid(dataset, num_users):num_items = int(len(dataset) / num_users)dict_users, all_idxs = {}, [i for i in range(len(dataset))]for i in range(num_users):# 随机从集合中获取num_items个idxdict_users[i] = set(np.random.choice(all_idxs, num_items, replace=False))# 从集合中删除已经分配掉的idxall_idxs = list(set(all_idxs) - dict_users[i])return dict_users

3.3 代码整合

net_glob.train()	#将模型切换为训练模式
w_glob = net_glob.state_dict()	#拷贝模型的权重loss_train_collect = []
acc_train_collect = []
loss_test_collect = []
acc_test_collect = []for iter in range(epochs):# w_locals, loss_locals_train, acc_locals_train, loss_locals_test, acc_locals_test = [], [], [], [], []m = max(int(frac * num_users), 1)idxs_users = np.random.choice(range(num_users), m, replace = False) #生成用户idxs的序列 # 对于每一个客户端进行模型训练for idx in idxs_users: # each clientlocal = LocalUpdate(idx, lr, device, dataset_train = dataset_train, dataset_test = dataset_test, idxs = dict_users[idx], idxs_test = dict_users_test[idx])# Training ------------------收集每一个客户端的w, loss_train, acc_trainw, loss_train, acc_train = local.train(net = copy.deepcopy(net_glob).to(device))# 使用服务端的参数进行模型的训练，经过该客户端本地的数据训练后产生一个新的模型参数w_locals.append(copy.deepcopy(w))loss_locals_train.append(copy.deepcopy(loss_train))acc_locals_train.append(copy.deepcopy(acc_train))# Testing -------------------收集每一个客户端的loss_test, acc_testloss_test, acc_test = local.evaluate(net = copy.deepcopy(net_glob).to(device))loss_locals_test.append(copy.deepcopy(loss_test))acc_locals_test.append(copy.deepcopy(acc_test))# Federation process 聚合各个客户端的ww_glob = FedAvg(w_locals)print("------------------------------------------------")print("------ Federation process at Server-Side -------")print("------------------------------------------------")# update global model --- copy weight to net_glob -- distributed the model to all users //更新全局模型net_glob.load_state_dict(w_glob)# Train/Test accuracy	添加训练和测试的准确率acc_avg_train = sum(acc_locals_train) / len(acc_locals_train)acc_train_collect.append(acc_avg_train)acc_avg_test = sum(acc_locals_test) / len(acc_locals_test)acc_test_collect.append(acc_avg_test)# Train/Test loss	添加训练和测试的lossloss_avg_train = sum(loss_locals_train) / len(loss_locals_train)loss_train_collect.append(loss_avg_train)loss_avg_test = sum(loss_locals_test) / len(loss_locals_test)loss_test_collect.append(loss_avg_test)print('------------------- SERVER ----------------------------------------------')print('Train: Round {:3d}, Avg Accuracy {:.3f} | Avg Loss {:.3f}'.format(iter, acc_avg_train, loss_avg_train))print('Test:  Round {:3d}, Avg Accuracy {:.3f} | Avg Loss {:.3f}'.format(iter, acc_avg_test, loss_avg_test))print('-------------------------------------------------------------------------')
#===================================================================================     
print("Training and Evaluation completed!")

4. SFLV1_ResNet_HAM10000.py

这个文件是论文中主要提到的模型，实现了拆分学习和联邦学习的结合。

4.1 ResNet18_client_side

这段代码定义了客户端部分的数据提取部分：

class ResNet18_client_side(nn.Module):def __init__(self):super(ResNet18_client_side, self).__init__()self.layer1 = nn.Sequential (nn.Conv2d(3, 64, kernel_size = 7, stride = 2, padding = 3, bias = False),nn.BatchNorm2d(64),nn.ReLU (inplace = True),nn.MaxPool2d(kernel_size = 3, stride = 2, padding =1),)self.layer2 = nn.Sequential  (nn.Conv2d(64, 64, kernel_size = 3, stride = 1, padding = 1, bias = False),nn.BatchNorm2d(64),nn.ReLU (inplace = True),nn.Conv2d(64, 64, kernel_size = 3, stride = 1, padding = 1),nn.BatchNorm2d(64),              )for m in self.modules():if isinstance(m, nn.Conv2d):n = m.kernel_size[0] * m.kernel_size[1] * m.out_channelsm.weight.data.normal_(0, math.sqrt(2. / n))elif isinstance(m, nn.BatchNorm2d):m.weight.data.fill_(1)m.bias.data.zero_()def forward(self, x):resudial1 = F.relu(self.layer1(x))out1 = self.layer2(resudial1)out1 = out1 + resudial1 # adding the resudial inputs -- downsampling not required in this layerresudial2 = F.relu(out1)return resudial2

4.2 ResNet18_server_side

我们可以看出客户端的模型+服务器的模型才是一个完整的模型

class ResNet18_server_side(nn.Module):def __init__(self, block, num_layers, classes):super(ResNet18_server_side, self).__init__()self.input_planes = 64self.layer3 = nn.Sequential (nn.Conv2d(64, 64, kernel_size = 3, stride = 1, padding = 1),nn.BatchNorm2d(64),nn.ReLU (inplace = True),nn.Conv2d(64, 64, kernel_size = 3, stride = 1, padding = 1),nn.BatchNorm2d(64),       )self.layer4 = self._layer(block, 128, num_layers[0], stride = 2)self.layer5 = self._layer(block, 256, num_layers[1], stride = 2)self.layer6 = self._layer(block, 512, num_layers[2], stride = 2)self. averagePool = nn.AvgPool2d(kernel_size = 7, stride = 1)self.fc = nn.Linear(512 * block.expansion, classes)for m in self.modules():if isinstance(m, nn.Conv2d):n = m.kernel_size[0] * m.kernel_size[1] * m.out_channelsm.weight.data.normal_(0, math.sqrt(2. / n))elif isinstance(m, nn.BatchNorm2d):m.weight.data.fill_(1)m.bias.data.zero_()def _layer(self, block, planes, num_layers, stride = 2):dim_change = Noneif stride != 1 or planes != self.input_planes * block.expansion:dim_change = nn.Sequential(nn.Conv2d(self.input_planes, planes*block.expansion, kernel_size = 1, stride = stride),nn.BatchNorm2d(planes*block.expansion))netLayers = []netLayers.append(block(self.input_planes, planes, stride = stride, dim_change = dim_change))self.input_planes = planes * block.expansionfor i in range(1, num_layers):netLayers.append(block(self.input_planes, planes))self.input_planes = planes * block.expansionreturn nn.Sequential(*netLayers)def forward(self, x):out2 = self.layer3(x)out2 = out2 + x          # adding the resudial inputs -- downsampling not required in this layerx3 = F.relu(out2)x4 = self. layer4(x3)x5 = self.layer5(x4)x6 = self.layer6(x5)x7 = F.avg_pool2d(x6, 7)x8 = x7.view(x7.size(0), -1) y_hat =self.fc(x8)return y_hat

4.3 服务器端的训练函数

# fx_client 客户端提取后的输出
# y	对应的标签
# l_epoch_count epoch的总数
# l_epoch	当前是第i轮epoch
# idx	客户端标识
# len_batch	batch的大小
def train_server(fx_client, y, l_epoch_count, l_epoch, idx, len_batch):	#声明全局变量，方便直接进行修改外部同名变量 global net_model_server, criterion, optimizer_server, device, batch_acc_train, batch_loss_train, l_epoch_check, fed_checkglobal loss_train_collect, acc_train_collect, count1, acc_avg_all_user_train, loss_avg_all_user_train, idx_collect, w_locals_server, w_glob_server, net_serverglobal loss_train_collect_user, acc_train_collect_user, lrnet_server = copy.deepcopy(net_model_server[idx]).to(device)#根据idx获取对应的服务端的模型net_server.train()optimizer_server = torch.optim.Adam(net_server.parameters(), lr = lr)# train and updateoptimizer_server.zero_grad()fx_client = fx_client.to(device)# 将客户端返回的中间数据放入devicey = y.to(device)#---------forward prop模型推理-------------fx_server = net_server(fx_client)# calculate lossloss = criterion(fx_server, y)# calculate accuracyacc = calculate_accuracy(fx_server, y)#--------backward prop--------------loss.backward()dfx_client = fx_client.grad.clone().detach()#获得模型的梯度并返回optimizer_server.step()batch_loss_train.append(loss.item())batch_acc_train.append(acc.item())# 更新当前轮次对应的server-side模型net_model_server[idx] = copy.deepcopy(net_server)# count1: to track the completion of the local batch associated with one clientcount1 += 1if count1 == len_batch:# 判断是否完成一个本地轮次：当count1等于len_batch时，计算本批次平均精度和损失，清空训练损失和精度集合，重置计数器，并打印训练信息。acc_avg_train = sum(batch_acc_train)/len(batch_acc_train)loss_avg_train = sum(batch_loss_train)/len(batch_loss_train)batch_acc_train = []batch_loss_train = []count1 = 0prRed('Client{} Train => Local Epoch: {} \tAcc: {:.3f} \tLoss: {:.4f}'.format(idx, l_epoch_count, acc_avg_train, loss_avg_train))# 保存当前模型权重：保存当前服务器端模型权重到w_server    w_server = net_server.state_dict()      if l_epoch_count == l_epoch-1:# 判断是否完成一个一定数量的epochl_epoch_check = True     #将当前模型权重添加到本地权重列表w_locals_serverw_locals_server.append(copy.deepcopy(w_server))#计算并保存当前客户端最后一个批次的精度和损失（非平均值）acc_avg_train_all = acc_avg_trainloss_avg_train_all = loss_avg_trainloss_train_collect_user.append(loss_avg_train_all)acc_train_collect_user.append(acc_avg_train_all)# 将当前客户端索引添加到用户索引集合idx_collect                      if idx not in idx_collect:idx_collect.append(idx) # 如果已收集到所有用户的索引，设置fed_check为True，表示触发联邦过程if len(idx_collect) == num_users:fed_check = True                                                  # to # 聚合通过各个客户端训练得到的服务器模型                       w_glob_server = FedAvg(w_locals_server)   # 服务器端的全局模型更新net_glob_server.load_state_dict(w_glob_server)    net_model_server = [net_glob_server for i in range(num_users)]w_locals_server = []idx_collect = []acc_avg_all_user_train = sum(acc_train_collect_user)/len(acc_train_collect_user)loss_avg_all_user_train = sum(loss_train_collect_user)/len(loss_train_collect_user)loss_train_collect.append(loss_avg_all_user_train)acc_train_collect.append(acc_avg_all_user_train)acc_train_collect_user = []loss_train_collect_user = []# send gradients to the client               return dfx_client

4.4 Client

class Client(object):# net_client_mode	客户端模型# idx	客户端id# lr	学习率# device	设备# dataset_train	训练的数据集	# dataset_test	测试的数据集# idxs	训练数据的子集# idxs_test	测试数据的子集def __init__(self, net_client_model, idx, lr, device, dataset_train = None, dataset_test = None, idxs = None, idxs_test = None):self.idx = idxself.device = deviceself.lr = lrself.local_ep = 1	#定义了本地的epochself.ldr_train = DataLoader(DatasetSplit(dataset_train, idxs), batch_size = 256, shuffle = True)self.ldr_test = DataLoader(DatasetSplit(dataset_test, idxs_test), batch_size = 256, shuffle = True)def train(self, net):net.train()optimizer_client = torch.optim.Adam(net.parameters(), lr = self.lr) #客户端的优化器for iter in range(self.local_ep):len_batch = len(self.ldr_train)  #获取batch的长度for batch_idx, (images, labels) in enumerate(self.ldr_train):images, labels = images.to(self.device), labels.to(self.device)optimizer_client.zero_grad()fx = net(images) # 正向传播client_fx = fx.clone().detach().requires_grad_(True) # 客户端提取的数据信息# 获得反向传播的梯度dfx = train_server(client_fx, labels, iter, self.local_ep, self.idx, len_batch)#--------backward prop -------------fx.backward(dfx)	# 在客户端继续反向传播optimizer_client.step()#  返回更新后的网络参数        return net.state_dict() def evaluate(self, net, ell):net.eval()with torch.no_grad():len_batch = len(self.ldr_test)for batch_idx, (images, labels) in enumerate(self.ldr_test):images, labels = images.to(self.device), labels.to(self.device)#---------forward prop-------------fx = net(images) # 正向传播evaluate_server(fx, labels, self.idx, len_batch, ell)return

4.5 整合技术

在这里插入图片描述

#------------ Training And Testing  -----------------
net_glob_client.train()
# 拷贝权重
w_glob_client = net_glob_client.state_dict()
# 联邦学习n轮
for iter in range(epochs):m = max(int(frac * num_users), 1)# 生成每个用户所拥有的数据的idxidxs_users = np.random.choice(range(num_users), m, replace = False)w_locals_client = []for idx in idxs_users:local = Client(net_glob_client, idx, lr, device, dataset_train = dataset_train, dataset_test = dataset_test, idxs = dict_users[idx], idxs_test = dict_users_test[idx])# Training ------------------# 训练，传给服务端，反向传播，更新后获得新的客户端模型参数w_client = local.train(net = copy.deepcopy(net_glob_client).to(device))w_locals_client.append(copy.deepcopy(w_client))# Testing -------------------local.evaluate(net = copy.deepcopy(net_glob_client).to(device), ell= iter)# 对客户端的模型参数求平均w_glob_client = FedAvg(w_locals_client)   # 更新客户端的全局模型net_glob_client.load_state_dict(w_glob_client)    
print("Training and Evaluation completed!")

5.总结

优点：

  • 代码实现了分割学习和联邦学习的结合模拟实验
  • 代码注释多，结构清晰

缺点：

  • 仅仅只是一个单机实验，没有在真实的多机环境中进行实验

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/824784.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

51单片机入门_江协科技_33~34_OB记录的自学笔记_LED呼吸灯与PWM直流马达调速

51单片机入门_江协科技_33~34_OB记录的自学笔记_LED呼吸灯与PWM直流马达调速

33. 直流电机驱动(PWM) 33.1. 直流电机介绍 •直流电机是一种将电能转换为机械能的装置。一般的直流电机有两个电极，当电极正接时，电机正转，当电极反接时，电机反转 •直流电机主要由永磁体（定子）、线圈&…
阅读更多...
笔记本触摸板的使用

笔记本触摸板的使用

使用电脑很多面年了，但很少使用触摸板，最近公司配置了台新笔记本触摸板很丝滑，像着改变一下多年使用电脑的习惯，做个笔记，使用它，适应它！ 单手指： 单击→左键 两次单击→打开文件夹&…
阅读更多...
MySQL 死锁案例解析一则

MySQL 死锁案例解析一则

原文链接：https://www.modb.pro/db/448666 一、问题背景某业务模块反馈数据库最近出现过几次死锁告警的情况，本文总结了这次死锁排查的全过程，并分析了导致死锁的原因及解决方案。希望给大家提供一个死锁的排查及解决思路。基础环境&#xff…
阅读更多...
绩效考核管理：激发潜力，实现双赢

绩效考核管理：激发潜力，实现双赢

绩效考核管理是现代企业管理中不可或缺的一环，它不仅关乎员工的个人发展，更影响着企业的整体战略目标实现。本文将从绩效考核管理的意义、目标设定、考核方法、激励措施以及持续改进等方面展开论述，探讨如何通过有效的绩效考核管理激发员工潜…
阅读更多...
Win10系统WSL2烧录SD卡（USB储存设备）

Win10系统WSL2烧录SD卡（USB储存设备）

众做周知在嵌入式开发中经常需要制作SD卡系统来启动开发板，最近从虚拟机转到WSL发现不能像以前那样对SD卡进行操作了，记录下解决方法（我的系统环境是Win10WSL2） 编译WSL2内核 由于WSL2的内核默认没有添加USB存储设备的驱动的支持…
阅读更多...
一.NODE MCU(ESP8285,ESP8286)开发环境搭建

一.NODE MCU(ESP8285,ESP8286)开发环境搭建

一.序言： 1.esp8285长什么样？ 2.esp8285是什么，能做什么？ 通过上面图片，看到上面的芯片，是带有多个阵脚的单片机。实际上，看着该芯片很小，但是却具有完整的wifi无线蓝牙功能，它本身可以运行一个极简的linux小系统，并且该极简的小linux系统具备无线蓝牙功能。。它同…
阅读更多...
Linux: 性能: sysctl vs echo vs直接使用fopen

Linux: 性能: sysctl vs echo vs直接使用fopen

简介 在实际的生产中，需要对系统参数做修改，有三种方式可以实现，一个是sysctl命令来修改，一个是使用echo 命令来写入，另一个是使用fopen/write接口函数来操作配置文件。 这个对比也是相当的明显，echo要比s…
阅读更多...
54岁前港姐与好友因一事反目成仇，20年后方破冰

54岁前港姐与好友因一事反目成仇，20年后方破冰

现年54岁的前「金牌司仪」陈淽菁（前名：陈芷菁）是1994年落选港姐，之后加入TVB参演电视剧《天地男儿》、《壹号皇庭》入屋，后因口齿伶俐而转战主持界。2017年陈淽菁离巢，外出以个人名义成立「陈芷菁工作室」&…
阅读更多...
每日学习笔记：C++ STL算法之容器元素转换、结合、互换

每日学习笔记：C++ STL算法之容器元素转换、结合、互换

本文API 转换元素 transform(sourceBeg,sourceEnd,destBeg, op) 结合元素 transform(source1Beg,source1End,source2Beg,destBeg, op) 互换元素 swap_ranges(sourceBeg,sourceEnd,destBeg) 转换元素 结合元素 互换元素
阅读更多...
聚焦ChatGPT：让论文写作更高效更精准

聚焦ChatGPT：让论文写作更高效更精准

ChatGPT无限次数:点击直达 html 聚焦ChatGPT：让论文写作更高效更精准 引言 在当今信息爆炸的时代，撰写高质量论文变得越发重要。然而，许多研究者和学者在论文写作过程中常常遇到困难，例如构思内容、整合观点和确保表达准确。…
阅读更多...
什么是Cookies？请求Cookies和响应 Cookies的关系

什么是Cookies？请求Cookies和响应 Cookies的关系

一、什么是cookies 在早期的网络发展中，如何管理状态一直是一个棘手的问题。由于HTTP协议的无状态特性，服务器无法判断连续的两个请求是否来自同一个浏览器。为了解决这个问题，最初的方案是在请求时将一些参数嵌入到页面中，并在…
阅读更多...
深度学习驱动的流体力学计算与应用

深度学习驱动的流体力学计算与应用

在深度学习与流体力学深度融合的背景下，科研边界不断拓展，创新成果层出不穷。从物理模型融合到复杂流动模拟，从数据驱动研究到流场智能分析，深度学习正以前所未有的力量重塑流体力学领域。近期在Nature和Science杂志上发表的深度学…
阅读更多...
ARM_day8：温湿度数据采集应用

ARM_day8：温湿度数据采集应用

1、IIC通信过程 主机发送起始信号、主机发送8位(7位从机地址1位传送方向(0W，1R))、从机应答、发数据、应答、数据传输完，主机发送停止信号 2、起始信号和终止信号 SCL时钟线，SDA数据线 SCL高电平，SDA由高到低——起始信号 SC…
阅读更多...
继承的初步

继承的初步

完成两个类，一个类Animal，表示动物类，有一个成员表示年龄。一个类Dog，继承自Animal，有一个新的数据成员表示颜色，合理设计这两个类，使得测试程序可以运行并得到正确的结果。 函数接口定义&…
阅读更多...
我为什么选择做程序员

我为什么选择做程序员

我选择做程序员的原因有多个方面。首先，我对计算机科学和技术有着浓厚的兴趣。从小我就对计算机的工作原理和软件开发充满好奇，喜欢探索新技术和解决问题。这种兴趣促使我深入学习和研究计算机领域的知识，最终选择了程序员这一职业。 其次&a…
阅读更多...
php正则表达式压缩与格式化html,css,js

php正则表达式压缩与格式化html,css,js

注意事项 只支持压缩含一个<script></script>的html,且变量内多个空格也会被压缩为一个 格式化html单标签需要添加/结束 压缩html 去除<!-- -->内的全部内容 多个空白符变为一个空格 去除> <内的空白符 压缩css 去除/* */内的全部内容 多个空白符变为一…
阅读更多...
汽车零部件制造迎来智能化升级，3D视觉定位系统助力无人化生产线建设

汽车零部件制造迎来智能化升级，3D视觉定位系统助力无人化生产线建设

随着新能源汽车市场的蓬勃发展&#xff0c;汽车零部件制造行业正面临着前所未有的机遇与挑战。为了提高产能和产品加工精度&#xff0c;某专业铝合金汽车零部件制造商决定引进智能生产线&#xff0c;其中&#xff0c;对成垛摆放的变速箱壳体进行机床上料成为关键一环。 传统的上…
阅读更多...
小程序如何引入自定义组件

小程序如何引入自定义组件

要在小程序中引入自定义组件&#xff0c;你可以按照以下步骤进行操作&#xff1a; 1. 创建自定义组件&#xff1a;首先在小程序项目中创建一个自定义组件。在项目目录下的components文件夹中创建一个新的文件夹&#xff0c;用于存放自定义组件相关的文件。通常&#xff0c;一个…
阅读更多...
CESSCN认证通信网络安全服务能力评定企业资质介绍

CESSCN认证通信网络安全服务能力评定企业资质介绍

通信网络安全服务能力评定资质是中国通信企业协会通信网络安全专业委员会&#xff08;简称通信安委会&#xff09;颁发的一项专业资质&#xff0c;旨在评定通信网络安全服务单位的服务资格、水平和能力。这项资质对于从事网络安全服务的企业尤为重要&#xff0c;因为它直接反映…
阅读更多...
SpringBootSpringCloud升级可能会出现的问题

SpringBootSpringCloud升级可能会出现的问题

1.背景 之前负责过我们中台的SpringBoot和Cloud的升级&#xff0c;特次记录分享一下项目中可能出现的问题&#xff0c;方便后续的人快速定位问题。以及下述选择的解决方案都是基于让升级的服务影响和改动最小以及提供通用的解决方案的提前进行选择的。 1.1版本说明 升级前&a…
阅读更多...
最新文章

Copyright @ 2022~2023