技术标签： 小菜鸡加油
网络的输出层设置两个神经元的原因：神经网络有两个输出值对应两种类别，通过学习数据的不同特征，让两种类别在输出上有体现，即0趋近于猫，1趋近于狗。宏观上来看，神经网络具有了辨识猫狗的能力。
训练过程中，有对GT由一维处理成二维的操作，目的也是为了和神经网络二维的输出进行匹配。
程序1中测试程序有误。程序2进行了修改，修改后在12000张图片中正确率达到了90%，浮动在2%以内，二分类的全连接网络效果还是可以的。
程序1：
import torch
import os
import numpy as np
from PIL import Image
from torch.utils.data import Dataset, DataLoader
import torch.nn as nn
import matplotlib.pyplot as plt
class MyDataSet(Dataset):
def __init__(self, path):
"""根据路径获得数据集"""
self.path = path
"""读取路径下的所有文件"""
self.dataset = os.listdir(self.path)
# 均值和方差的求解过程下面会交代
self.mean = [0.4878, 0.4545, 0.4168]
self.std = [0.2623, 0.2555, 0.2577]
def __len__(self):
"""获取数据集的长度"""
# print("ooo")
return len(self.dataset)
def __getitem__(self, index):
"""根据索引获得数据集"""
# 获得数据的标签
name = self.dataset[index]
# 数据集的文件名为i.j.jpeg, 这个标签的第i个位置如果是0表示猫，1则表示狗，第j个位置是图片的个数
name_list = name.split(".")
target = int(name_list[0])
# 这里需要注意，tensor(target) 和Tensor([target])的区别，否则在one-hot解码的时候会出现错误
target = torch.tensor(target)
"""数据预处理"""
# 打开图片
img = Image.open(os.path.join(self.path, name))
# 设置图片大小
# img = np.resize(img, (3, 10, 10))
# 归一化，先将图片转化为一个矩阵，然后除以255
img = np.array(img) / 255
# print("OOK")
# # 去均值
img = (img - self.mean) / self.std
# 换轴 H W C 转换为 C H W ，这里需要注意下，其实我们可以不这么处理，在前面设置图片大小的时候设置为3 * 100 * 100 的就可以。
train_data = torch.tensor(img, dtype=torch.float32).permute(2, 0, 1)
return train_data, target
# def aaa(self):
# print("OK")
class MyNetwork(nn.Module):
def __init__(self):
super(MyNetwork, self).__init__()
"""
nn.Sequential:一个有序的容器，神经网络模块将按照在传入构造器的顺序依次被添加到计算图中执行
"""
self.line1 = nn.Sequential(
nn.Linear(in_features=3 * 100 * 100, out_features=512),
nn.ReLU(),
nn.Linear(in_features=512, out_features=256),
nn.ReLU(),
nn.Linear(in_features=256, out_features=128),
nn.ReLU(),
nn.Linear(in_features=128, out_features=256),
nn.ReLU(),
nn.Linear(in_features=256, out_features=512),
nn.ReLU(),
nn.Linear(in_features=512, out_features=256),
nn.ReLU(),
nn.Linear(in_features=256, out_features=2),
)
def forward(self, parse):
data = torch.reshape(parse, shape=(-1, 3 * 100 * 100))
return self.line1(data)
class Train(object):
def __init__(self, path):
self.path = path
self.test_dataset = MyDataSet(os.path.join(self.path))
self.train_dataset = MyDataSet(os.path.join(self.path))
self.criterion = torch.nn.MSELoss()
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.net = MyNetwork().to(self.device)
self.optimize = torch.optim.Adam(self.net.parameters())
def dataLoader(self, batch):
train_data_loader = DataLoader(dataset=self.train_dataset, batch_size=batch, shuffle=True)
test_data_loader = DataLoader(dataset=self.test_dataset, batch_size=batch, shuffle=True)
return train_data_loader, test_data_loader
def trainNet(self, batch, epoch):
train_data_loader, test_data_loader = self.dataLoader(batch)
losses = []
accuracy = []
for i in range(epoch):
for j, (Input, target) in enumerate(train_data_loader):
Input = Input.to(self.device)
out_put = self.net(Input)
# print("out_put:",out_put)
"""
one - hot 编码：
torch.scatter(self, dim, index, value)
该代码表示把value按照index根据dim的方向填入self中
Example:
index = torch.tensor([0, 2, 4, 1])
src = torch.zeros(4, 5)
print(src.shape)
out = torch.scatter(src, dim=1, index=index.view(-1, 1), value=1)
print(out)
"""
# print(target,target.size())
target = torch.zeros(target.size(0), 2).scatter_(1, target.view(-1, 1), 1).to(self.device)
# print(target,target.size())
# input()
loss = self.criterion(out_put, target)
a=loss.item()
losses.append(loss.item())
""" 梯度清零"""
self.optimize.zero_grad()
loss.backward()
self.optimize.step()
if j % 5 == 0:
print("训练轮次：epoch{}/{}，迭代次数：iteration{}/{}".format(i, epoch, j, len(train_data_loader)))
# print(out_put,out_put.argmax(1))
# print(target,target.argmax(1))
# input()
acc = torch.mean((out_put.argmax(1) == target.argmax(1)), dtype=torch.float32)
accuracy.append(acc.item())
print("训练准确率为：accuracy = %s , loss值为：%s" % (acc.item(), loss.item()))
plt.clf()
plt.ion()
"""加载loss曲线"""
plt.subplot(2, 1, 1)
plt.tight_layout(2)
plt.plot(losses, label="loss")
plt.legend(loc='best')
"""加载accuracy曲线"""
plt.subplot(2, 1, 2)
"""设置图像之间的距离"""
plt.tight_layout(2)
plt.plot(accuracy, label="accuracy")
"""显示图例"""
plt.legend(loc='best')
plt.pause(0.01)
plt.show()
torch.save(self.net, "model/net.pth")
# 测试
def Test(self, batch):
train_data_loader, test_data_loader = self.dataLoader(batch)
plt.ion()
for k, (In, tgt) in enumerate(test_data_loader):
print(k)
print(self.device)
# In = In.to(self.device)
In=In.cuda()
"""加载测试图片"""
# 加载训练好的网络
test_Net = torch.load('model/net.pth')
# 这是可视化训练图片的第一步，进行反算（Input * 标准差+均值）*255
# 这里输入In的维度是（batch, 3, 100, 100 ），std 和mean是矩阵，所以给它转换维度才能与输入做运算
img = (In.cpu().data.numpy() * np.array(self.train_dataset.std).reshape(1, 3, 1, 1) + np.array(
self.train_dataset.mean).reshape(1, 3, 1, 1)) * 255
img = np.resize(img, (100, 100))
"""显示测试结果"""
if 0 < k <= batch:
plt.subplot(3, 3, k)
plt.tight_layout(1)
plt.imshow(img)
predict = test_Net(In)
print("predict", torch.argmax((predict[k-1])).item())
predict_result = "cat" if torch.argmax(predict[k - 1]).item() == 0 else "dog"
print(predict_result)
plt.title(predict_result)
plt.axis('off')
plt.pause(1)
plt.show()
plt.savefig("result.jpg")
elif k == 0:
continue
else:
print("图片测试完毕，请查看！")
break
if __name__ == '__main__':
path = r"./cat_dog/img"
# 训练
t = Train(path)
t.trainNet(50, 10)
# 测试
t.Test(batch=11)对测试部分程序进行修改。
程序2：
import torch
import os
import numpy as np
from PIL import Image
from torch.utils.data import Dataset, DataLoader
import torch.nn as nn
import matplotlib.pyplot as plt
class MyDataSet(Dataset):
def __init__(self, path):
"""根据路径获得数据集"""
self.path = path
"""读取路径下的所有文件"""
self.dataset = os.listdir(self.path)
# 均值和方差的求解过程下面会交代
self.mean = [0.4878, 0.4545, 0.4168]
self.std = [0.2623, 0.2555, 0.2577]
def __len__(self):
"""获取数据集的长度"""
# print("ooo")
return len(self.dataset)
def __getitem__(self, index):
"""根据索引获得数据集"""
# 获得数据的标签
name = self.dataset[index]
# 数据集的文件名为i.j.jpeg, 这个标签的第i个位置如果是0表示猫，1则表示狗，第j个位置是图片的个数
name_list = name.split(".")
target = int(name_list[0])
# 这里需要注意，tensor(target) 和Tensor([target])的区别，否则在one-hot解码的时候会出现错误
target = torch.tensor(target)
"""数据预处理"""
# 打开图片
img = Image.open(os.path.join(self.path, name))
# 设置图片大小
# img = np.resize(img, (3, 10, 10))
# 归一化，先将图片转化为一个矩阵，然后除以255
img = np.array(img) / 255
# print("OOK")
# # 去均值
img = (img - self.mean) / self.std
# 换轴 H W C 转换为 C H W ，这里需要注意下，其实我们可以不这么处理，在前面设置图片大小的时候设置为3 * 100 * 100 的就可以。
train_data = torch.tensor(img, dtype=torch.float32).permute(2, 0, 1)
return train_data, target
# def aaa(self):
# print("OK")
class MyNetwork(nn.Module):
def __init__(self):
super(MyNetwork, self).__init__()
"""
nn.Sequential:一个有序的容器，神经网络模块将按照在传入构造器的顺序依次被添加到计算图中执行
"""
self.line1 = nn.Sequential(
nn.Linear(in_features=3 * 100 * 100, out_features=512),
nn.ReLU(),
nn.Linear(in_features=512, out_features=256),
nn.ReLU(),
nn.Linear(in_features=256, out_features=128),
nn.ReLU(),
nn.Linear(in_features=128, out_features=256),
nn.ReLU(),
nn.Linear(in_features=256, out_features=512),
nn.ReLU(),
nn.Linear(in_features=512, out_features=256),
nn.ReLU(),
nn.Linear(in_features=256, out_features=2),
)
def forward(self, parse):
data = torch.reshape(parse, shape=(-1, 3 * 100 * 100))
return self.line1(data)
class Train(object):
def __init__(self, path):
self.path = path
self.test_dataset = MyDataSet(os.path.join(self.path))
self.train_dataset = MyDataSet(os.path.join(self.path))
self.criterion = torch.nn.MSELoss()
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.net = MyNetwork().to(self.device)
self.optimize = torch.optim.Adam(self.net.parameters())
def dataLoader(self, batch):
train_data_loader = DataLoader(dataset=self.train_dataset, batch_size=batch, shuffle=True)
test_data_loader = DataLoader(dataset=self.test_dataset, batch_size=batch, shuffle=True)
return train_data_loader, test_data_loader
def trainNet(self, batch, epoch):
train_data_loader, test_data_loader = self.dataLoader(batch)
losses = []
accuracy = []
for i in range(epoch):
for j, (Input, target) in enumerate(train_data_loader):
Input = Input.to(self.device)
out_put = self.net(Input)
# print("out_put:",out_put)
"""
one - hot 编码：
torch.scatter(self, dim, index, value)
该代码表示把value按照index根据dim的方向填入self中
Example:
index = torch.tensor([0, 2, 4, 1])
src = torch.zeros(4, 5)
print(src.shape)
out = torch.scatter(src, dim=1, index=index.view(-1, 1), value=1)
print(out)
"""
# print(target,target.size())
target = torch.zeros(target.size(0), 2).scatter_(1, target.view(-1, 1), 1).to(self.device)
# print(target,target.size())
# input()
loss = self.criterion(out_put, target)
a = loss.item()
losses.append(loss.item())
""" 梯度清零"""
self.optimize.zero_grad()
loss.backward()
self.optimize.step()
if j % 5 == 0:
print("训练轮次：epoch{}/{}，迭代次数：iteration{}/{}".format(i, epoch, j, len(train_data_loader)))
# print(out_put,out_put.argmax(1))
# print(target,target.argmax(1))
# input()
acc = torch.mean((out_put.argmax(1) == target.argmax(1)), dtype=torch.float32)
accuracy.append(acc.item())
print("训练准确率为：accuracy = %s , loss值为：%s" % (acc.item(), loss.item()))
plt.clf()
plt.ion()
"""加载loss曲线"""
plt.subplot(2, 1, 1)
plt.tight_layout(2)
plt.plot(losses, label="loss")
plt.legend(loc='best')
"""加载accuracy曲线"""
plt.subplot(2, 1, 2)
"""设置图像之间的距离"""
plt.tight_layout(2)
plt.plot(accuracy, label="accuracy")
"""显示图例"""
plt.legend(loc='best')
plt.pause(0.01)
plt.show()
torch.save(self.net, "model/net.pth")
# 测试
def Test(self, batch):
train_data_loader, test_data_loader = self.dataLoader(batch)
plt.ion()
i = 0
for k, (In, tgt) in enumerate(test_data_loader):
print(k)
print(self.device)
# In = In.to(self.device)
In = In.cuda()
# print(In.size())
# input()
"""加载测试图片"""
# 加载训练好的网络
test_Net = torch.load('model/net.pth')
# 这是可视化训练图片的第一步，进行反算（Input * 标准差+均值）*255
# 这里输入In的维度是（batch, 3, 100, 100 ），std 和mean是矩阵，所以给它转换维度才能与输入做运算
img = (In.cpu().data.numpy() * np.array(self.train_dataset.std).reshape(1, 3, 1, 1) + np.array(
self.train_dataset.mean).reshape(1, 3, 1, 1)) * 255
img = np.resize(img, (100, 100))
predict = test_Net(In)
# predict_result = "cat" if predict[k - 1].argmax(1).item() == 0 else "dog"
print(tgt)
# TP = np.intersect1d(tgt.cpu().numpy(),tgt.cpu().numpy())
print(predict.argmax(1).cpu())
print(predict)
print(predict.argmax(1).cpu() == tgt.cpu())
for x in predict.argmax(1).cpu() == tgt.cpu():
if x == True:
i += 1
print(i)
# input()
# print(len(tgt.cpu() == predict.argmax(1).cpu()))
# print(len(TP))
# print(TP / len(tgt))
# input()
print("{:%}".format(i/12000))
#
# """显示测试结果"""
# if 0 < k <= batch:
# plt.subplot(3, 3, k)
# plt.tight_layout(1)
# plt.imshow(img)
# predict = test_Net(In)
# print(predict.size(),predict)
# input()
# # print("predict", torch.argmax((predict[k-1])).item())
# predict_result = "cat" if predict[k - 1].argmax(1).item() == 0 else "dog"
#
# print(predict_result)
# plt.title(predict_result)
# plt.axis('off')
# plt.pause(1)
# plt.show()
# plt.savefig("result.jpg")
# elif k == 0:
# continue
# else:
# print("图片测试完毕，请查看！")
# break
if __name__ == '__main__':
path = r"./cat_dog/img"
# 训练
t = Train(path)
t.trainNet(200, 10)
# 测试
t.Test(batch=200)注释去掉后：
import torch
import os
import numpy as np
from PIL import Image
from torch.utils.data import Dataset, DataLoader
import torch.nn as nn
import matplotlib.pyplot as plt
class MyDataSet(Dataset):
def __init__(self, path):
"""根据路径获得数据集"""
self.path = path
"""读取路径下的所有文件"""
self.dataset = os.listdir(self.path)
# 均值和方差的求解过程下面会交代
self.mean = [0.4878, 0.4545, 0.4168]
self.std = [0.2623, 0.2555, 0.2577]
def __len__(self):
"""获取数据集的长度"""
# print("ooo")
return len(self.dataset)
def __getitem__(self, index):
"""根据索引获得数据集"""
# 获得数据的标签
name = self.dataset[index]
# 数据集的文件名为i.j.jpeg, 这个标签的第i个位置如果是0表示猫，1则表示狗，第j个位置是图片的个数
name_list = name.split(".")
target = int(name_list[0])
# 这里需要注意，tensor(target) 和Tensor([target])的区别，否则在one-hot解码的时候会出现错误
target = torch.tensor(target)
"""数据预处理"""
# 打开图片
img = Image.open(os.path.join(self.path, name))
# 设置图片大小
# img = np.resize(img, (3, 10, 10))
# 归一化，先将图片转化为一个矩阵，然后除以255
img = np.array(img) / 255
# print("OOK")
# # 去均值
img = (img - self.mean) / self.std
# 换轴 H W C 转换为 C H W ，这里需要注意下，其实我们可以不这么处理，在前面设置图片大小的时候设置为3 * 100 * 100 的就可以。
train_data = torch.tensor(img, dtype=torch.float32).permute(2, 0, 1)
return train_data, target
# def aaa(self):
# print("OK")
class MyNetwork(nn.Module):
def __init__(self):
super(MyNetwork, self).__init__()
"""
nn.Sequential:一个有序的容器，神经网络模块将按照在传入构造器的顺序依次被添加到计算图中执行
"""
self.line1 = nn.Sequential(
nn.Linear(in_features=3 * 100 * 100, out_features=512),
nn.ReLU(),
nn.Linear(in_features=512, out_features=256),
nn.ReLU(),
nn.Linear(in_features=256, out_features=128),
nn.ReLU(),
nn.Linear(in_features=128, out_features=256),
nn.ReLU(),
nn.Linear(in_features=256, out_features=512),
nn.ReLU(),
nn.Linear(in_features=512, out_features=256),
nn.ReLU(),
nn.Linear(in_features=256, out_features=2),
)
def forward(self, parse):
data = torch.reshape(parse, shape=(-1, 3 * 100 * 100))
return self.line1(data)
class Train(object):
def __init__(self, path):
self.path = path
self.test_dataset = MyDataSet(os.path.join(self.path))
self.train_dataset = MyDataSet(os.path.join(self.path))
self.criterion = torch.nn.MSELoss()
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.net = MyNetwork().to(self.device)
self.optimize = torch.optim.Adam(self.net.parameters())
def dataLoader(self, batch):
train_data_loader = DataLoader(dataset=self.train_dataset, batch_size=batch, shuffle=True)
test_data_loader = DataLoader(dataset=self.test_dataset, batch_size=batch, shuffle=True)
return train_data_loader, test_data_loader
def trainNet(self, batch, epoch):
train_data_loader, test_data_loader = self.dataLoader(batch)
losses = []
accuracy = []
for i in range(epoch):
for j, (Input, target) in enumerate(train_data_loader):
Input = Input.to(self.device)
out_put = self.net(Input)
# print("out_put:",out_put)
"""
one - hot 编码：
torch.scatter(self, dim, index, value)
该代码表示把value按照index根据dim的方向填入self中
Example:
index = torch.tensor([0, 2, 4, 1])
src = torch.zeros(4, 5)
print(src.shape)
out = torch.scatter(src, dim=1, index=index.view(-1, 1), value=1)
print(out)
"""
# print(target,target.size())
target = torch.zeros(target.size(0), 2).scatter_(1, target.view(-1, 1), 1).to(self.device)
# print(target,target.size())
# input()
loss = self.criterion(out_put, target)
a = loss.item()
losses.append(loss.item())
""" 梯度清零"""
self.optimize.zero_grad()
loss.backward()
self.optimize.step()
if j % 5 == 0:
print("训练轮次：epoch{}/{}，迭代次数：iteration{}/{}".format(i, epoch, j, len(train_data_loader)))
# print(out_put,out_put.argmax(1))
# print(target,target.argmax(1))
# input()
acc = torch.mean((out_put.argmax(1) == target.argmax(1)), dtype=torch.float32)
accuracy.append(acc.item())
print("训练准确率为：accuracy = %s , loss值为：%s" % (acc.item(), loss.item()))
plt.clf()
plt.ion()
"""加载loss曲线"""
plt.subplot(2, 1, 1)
plt.tight_layout(2)
plt.plot(losses, label="loss")
plt.legend(loc='best')
"""加载accuracy曲线"""
plt.subplot(2, 1, 2)
"""设置图像之间的距离"""
plt.tight_layout(2)
plt.plot(accuracy, label="accuracy")
"""显示图例"""
plt.legend(loc='best')
plt.pause(0.01)
plt.show()
torch.save(self.net, "model/net.pth")
# 测试
def Test(self, batch):
train_data_loader, test_data_loader = self.dataLoader(batch)
plt.ion()
i = 0
for k, (In, tgt) in enumerate(test_data_loader):
print(k)
print(self.device)
# In = In.to(self.device)
In = In.cuda()
# print(In.size())
# input()
"""加载测试图片"""
# 加载训练好的网络
test_Net = torch.load('model/net.pth')
# 这是可视化训练图片的第一步，进行反算（Input * 标准差+均值）*255
# 这里输入In的维度是（batch, 3, 100, 100 ），std 和mean是矩阵，所以给它转换维度才能与输入做运算
img = (In.cpu().data.numpy() * np.array(self.train_dataset.std).reshape(1, 3, 1, 1) + np.array(
self.train_dataset.mean).reshape(1, 3, 1, 1)) * 255
img = np.resize(img, (100, 100))
predict = test_Net(In)
# predict_result = "cat" if predict[k - 1].argmax(1).item() == 0 else "dog"
print(tgt)
# TP = np.intersect1d(tgt.cpu().numpy(),tgt.cpu().numpy())
print(predict.argmax(1).cpu())
print(predict)
print(predict.argmax(1).cpu() == tgt.cpu())
for x in predict.argmax(1).cpu() == tgt.cpu():
if x == True:
i += 1
print(i)
print("{:%}".format(i/12000))
if __name__ == '__main__':
path = r"./cat_dog/img"
# 训练
t = Train(path)
t.trainNet(200, 10)
# 测试
t.Test(batch=200)文章浏览阅读645次。这个肯定是末尾的IDAT了，因为IDAT必须要满了才会开始一下个IDAT，这个明显就是末尾的IDAT了。，对应下面的create_head()代码。，对应下面的create_tail()代码。不要考虑爆破，我已经试了一下，太多情况了。题目来源：UNCTF。_攻防世界困难模式攻略图文
文章浏览阅读2.9k次，点赞3次，收藏10次。偶尔会用到，记录、分享。1. 数据库导出1.1 切换到dmdba用户su - dmdba1.2 进入达梦数据库安装路径的bin目录，执行导库操作 导出语句：./dexp cwy_init/[email protected]:5236 file=cwy_init.dmp log=cwy_init_exp.log 注释： cwy_init/init_123..._达梦数据库导入导出
文章浏览阅读1.9k次。1. 在官网上下载KindEditor文件，可以删掉不需要要到的jsp，asp，asp.net和php文件夹。接着把文件夹放到项目文件目录下。2. 修改html文件，在页面引入js文件：<script type="text/javascript" src="./kindeditor/kindeditor-all.js"></script><script type="text/javascript" src="./kindeditor/lang/zh-CN.js"_kindeditor.js
文章浏览阅读2.3k次，点赞6次，收藏14次。SPI的详情简介不必赘述。假设我们通过SPI发送0xAA，我们的数据线就会变为10101010，通过修改不同的内容，即可修改SPI中0和1的持续时间。比如0xF0即为前半周期为高电平，后半周期为低电平的状态。在SPI的通信模式中，CPHA配置会影响该实验，下图展示了不同采样位置的SPI时序图[1]。CPOL = 0，CPHA = 1：CLK空闲状态 = 低电平，数据在下降沿采样，并在上升沿移出CPOL = 0，CPHA = 0：CLK空闲状态 = 低电平，数据在上升沿采样，并在下降沿移出。_stm32g431cbu6
文章浏览阅读1.2k次，点赞2次，收藏8次。数据链路层习题自测问题1.数据链路(即逻辑链路)与链路(即物理链路)有何区别?“电路接通了”与”数据链路接通了”的区别何在?2.数据链路层中的链路控制包括哪些功能?试讨论数据链路层做成可靠的链路层有哪些优点和缺点。3.网络适配器的作用是什么?网络适配器工作在哪一层?4.数据链路层的三个基本问题(帧定界、透明传输和差错检测)为什么都必须加以解决？5.如果在数据链路层不进行帧定界，会发生什么问题？6.PPP协议的主要特点是什么？为什么PPP不使用帧的编号？PPP适用于什么情况？为什么PPP协议不_接收方收到链路层数据后,使用crc检验后,余数为0,说明链路层的传输时可靠传输
文章浏览阅读587次。软件测试工程师移民加拿大 无证移民，未受过软件工程师的教育(第1部分) (Undocumented Immigrant With No Education to Software Engineer(Part 1))Before I start, I want you to please bear with me on the way I write, I have very little gen...
文章浏览阅读304次。Thinkpad X250笔记本电脑，装的是FreeBSD，进入BIOS修改虚拟化配置（其后可能是误设置了安全开机），保存退出后系统无法启动，显示：secure boot failed ，把自己惊出一身冷汗，因为这台笔记本刚好还没开始做备份.....根据错误提示，到bios里面去找相关配置，在Security里面找到了Secure Boot选项，发现果然被设置为Enabled，将其修改为Disabled ，再开机，终于正常启动了。_安装完系统提示secureboot failure
文章浏览阅读10w+次，点赞93次，收藏352次。1、用strtok函数进行字符串分割原型： char *strtok(char *str, const char *delim);功能：分解字符串为一组字符串。参数说明：str为要分解的字符串，delim为分隔符字符串。返回值：从str开头开始的一个个被分割的串。当没有被分割的串时则返回NULL。其它：strtok函数线程不安全，可以使用strtok_r替代。示例：//借助strtok实现split#include <string.h>#include <stdio.h&_c++ 字符串分割
文章浏览阅读2.3k次。1 .高斯日记 大数学家高斯有个好习惯：无论如何都要记日记。他的日记有个与众不同的地方，他从不注明年月日，而是用一个整数代替，比如：4210后来人们知道，那个整数就是日期，它表示那一天是高斯出生后的第几天。这或许也是个好习惯，它时时刻刻提醒着主人：日子又过去一天，还有多少时光可以用于浪费呢？高斯出生于：1777年4月30日。在高斯发现的一个重要定理的日记_2013年第四届c a组蓝桥杯省赛真题解答
文章浏览阅读851次，点赞17次，收藏22次。摘要：本文利用供需算法对核极限学习机(KELM)进行优化，并用于分类。
文章浏览阅读1.1k次。一、系统弱密码登录1、在kali上执行命令行telnet 192.168.26.1292、Login和password都输入msfadmin3、登录成功，进入系统4、测试如下：二、MySQL弱密码登录：1、在kali上执行mysql –h 192.168.26.129 –u root2、登录成功，进入MySQL系统3、测试效果：三、PostgreSQL弱密码登录1、在Kali上执行psql -h 192.168.26.129 –U post..._metasploitable2怎么进入
文章浏览阅读257次。本文将为初学者提供Python学习的详细指南，从Python的历史、基础语法和数据类型到面向对象编程、模块和库的使用。通过本文，您将能够掌握Python编程的核心概念，为今后的编程学习和实践打下坚实基础。_python人工智能开发从入门到精通pdf