怎样解读SAM密码文件
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了怎样解读SAM密码文件相关的知识，希望对你有一定的参考价值。
老爸给电脑设密码了，限制我，每天只让弄一小时，怎么打开密码？听说有个sam文件，可是打不开，怎么办？？？？？说得明白点，加分哦！！
来来来,如果你爸爸是在用户中,而不是Administrator中设的密码,那么我可以教你一招打开电脑后按住F8不放,过后会出现一个菜单,选择最上面的"进入安全模式",然后你可以看到在你那个被设了密码的用户之外又有一个叫Administrator的用户,点击进入,进入后点开始,然后是运行,再出来的运行对话框里输入如下字列"control userpasswords2"回车,然后出现一个对话框,里面可以修改用户的各种属性,如果不想让你爸发现,你就建一个用户,然后重新启动计算机,按正常方式进入,然后进你刚建的用户就行,应记得玩完后删除你刚建的用户哦,否则会被发现
当然,你也可以用绝的,直接在"control userpasswords2"里面删除你爸爸的密码,甚至可以直接改掉他的密码哦~~~~
以上是系统密码的方式
如果是一开机就有密码,即刚打开电脑就出现密码输入框,那只有放电的方法了,方法如下:关掉电脑的总电源,打开机箱,在主板上可以找到一块姆指大小的钮扣电池,拔下它,过5分钟后再安上,就可以进入了,不过缺点是密码就没了,呵呵~~~
我当时就是这样和我爸爸玩捉迷藏的,注意不要玩得太过火了哦~~~
我的QQ:403357425 想做朋友的话加我哦 参考技术A 确定是管理员登入，然后安装lc4
这里需要的工具是LC4，运行LC4，打开并新建一个任务，然后依次点击“IMPORT→Import from SAM file”，打开已待破解的SAM文件，此时LC4会自动分析此文件，并显示出文件中的用户名；之后点击“Session→Begin Audit”，即可开始破解密码。如果密码不是很复杂的话，很短的时间内就会得到结果。
也可一运行向导，选择本机破解，效果好像比上面的方法要好一些。
假如一个小时没有破解完的时候，可以先暂停，然后等下一次再接着破解，破解完以后要记得将lc4卸载了，防止你老爸知道。
还有就是在破解的时候尽量不要干其它的工作，这样会破解的快一些。
这个方法我试过如果是数字的密码的话，6位在几分钟就可以破解，多了可能时间要加长。
下载地址：
http://www.gz235.com/Soft/14/2005/Soft_1170.htm 参考技术B 呵呵，破戒sam多麻烦啊，告诉你一个妙招吧
看好了
前提：你爸爸输入进入了系统，然后交给你操作
1、桌面--右键“我的电脑”--管理
2、左侧“本地用户和组”----用户
3、到右侧 空白处---右键---“新用户”
4、设置一个新用户，赋予超级用户权限保存
5、好了，以后就可以用这个交色登陆系统了，还不受任何限制，爽吧
6赶紧去实施吧
小心，别让你爸发现哦，呵呵 参考技术C 有一种方法很好用，不过要修改你帐号的密码
开机时，按F8，在跳出的选项中，选带命令行的安全模式
之后在dos界面上，输入：
net user administrator 123456
administrator：这个是超级管理员用户帐号，如果不存在的话，你也可以用你老爸的帐号，不过会把你老爸的修改掉
123456:是修改后的密码
重启后，就可以用这个帐号和修改后的密码登陆了
好用吧！！不过可不要让你老爸发现哦 参考技术D 这个太简单了，下次再上的时候新建一个用户，以后的时候偷偷用新建的那个用户上就可以了，你也可以试试用administrator用户进系统，密码空
SAM文件是不能够阅览的，不过你可以用专门软件删除，在DOS下也可以删除，不过你以前的用户就都不见了，很容易让你老爸知道
《最新开源 随插即用》SAM 自增强注意力深度解读与实践（附代码及分析）
写在前面
大家好，我是cv君，前段时间忙碌工作，许久没更新，越发觉得对不起csdn的读者们，决定继续加油保持更新，保持一周2-3篇的高频率和高质量文章更新：论文分析、代码讲解、代码实操和训练、优化部署技巧。 今天更新一篇注意力的最新文章，附带代码，就在上周开源的代码，我觉得还是凑合的一份工作，可圈可点，我把他优秀的东西分析一下，看看大家能不能拿过来到大家的工作中使用，并附带一些使用教学。好的，正文开始。
自增强注意机制（SAM）简介
细粒度视觉识别的挑战通常在于发现关键的判别区域。虽然可以从大规模标记的数据集中自动识别这些区域，但当只有少数注释可用时，类似的方法可能会变得不那么有效。在低数据状态下，网络通常难以选择正确的识别区域，并且往往过度拟合训练数据中的虚假相关模式。
为了解决这个问题，本文提出了自增强注意机制，这是一种新的方法，用于正则化网络，以关注样本和类之间共享的关键区域。
方法流程：
1：该方法首先为每个训练图像生成注意力图，突出用于识别地面真实对象类别的判别部分。
2： 将生成的注意力图用作伪注释。强制网络将其作为辅助任务。
作者将这种方法称为自增强注意力机制（SAM）。并开发了一种变体，使用SAM以双线性池的方式创建多个注意力映射到池卷积映射，称为SAM双线性，涨点更多一些罢了，实际的Flops多少，我还没去查看。
对于方法流程1,作者是通过CAM 和Grad CAM 的注意力机制，获得注意力图，这是其SAM的基础。
CAM 通过将输出层的权重投影回卷积特征图来识别图像区域的重要性。CAM适用于使用全局平均池（GAP）层和分类器层作为最后两层的神经网络架构。
表示最后一个卷积层的激活特征图，其中I是输入图像，H、W和D分别是特征图的高度、宽度和通道数。因此，类y的logit，即softmax之前的决策值，可以计算为：
其中，Wy是第y类的分类器, GAP表示全球平均池.
表示位于第（i，j）网格的特征向量。类y的类激活图（CAM）定义为：
其中CAM（y）表示第y类的CAM。[CAM（y）]i，j表示第（i，j）个空间网格的重要性值。
CAM与GradCAM简述
接着作者展示了基于CAM 和GradCAM的方法实现的SAM方案。
在上半部分（a），CNN网络中的最后一个卷积层特征映射通过全局平均池（GAP）和分类器（CLS）通过交叉熵损失函数CE。
这些通过线性投影的特征图也被强制用于拟合CAM生成的注意力图。下半部分（b）表示在双线性池中开发的方法。将多重投影应用于卷积特征映射以获得多个部分检测器。然后使用双线性池操作来获得新的特征表示。经过多次投影和通道最大化操作后的特征图也被强制用于拟合GradCAM生成的注意力图。
SAM改进策略
作者实验发现，训练样本的数量变小时，这种端到端训练策略在识别关键区域方面变得不那么有效。在这种情况下，虚假相关性和真实判别模式变得难以区分，网络经常错误地利用前者，导致泛化能力差。
作者首先计算CAM或者GradCAM等注意力的特征图，通过线性投影w强制ɕ（I）拟合g（In，yn）∈ 在不向网络提供groundtruth类信息的情况下进行R D，这可以实现为应用带有单个滤波器的卷积层
然后作者使用KL散度计算合并注意力图相关的计算损失：
作者自问自答： SAM Loss 的引入似乎有点违反直觉。注意力图是从当前模型生成的，为什么认为模型拟合它会带来任何好处？
为了理解它的效果，我们应该注意到注意力图是基于GT真值类计算的。例如，如果我们使用CAM计算注意力图，则CAM通过w计算，即，选择与地面真值类yn对应的分类器来生成CAM。相反，投影向量w是类不可知的。因此，w⊤ν（I）倾向于适合所有类和实例的共享的公共部分。于是就创建了一个用于鼓励网络使用常见模式的归纳偏差进行预测的关键部分。我们将这种机制称为自增强注意力机制，因为模型将通过拟合其自身的注意力图来增强。
实验结论
基于这个方法，在数据比例只有原有的10%情况下，提高了3%~10%，但是在数据量较多情况下，有0.几到2%左右的增长，整体来说，提升不是特别高，数据量越小提升越高。所以作者一直称在小数据中获得较高的提升。
不过有2%的提升，也还算不错了，毕竟现在很多水文可能至于0.1%的提升、更有甚者，拿久远的网络对比。
最后，作者和双线性池方法的sota网络做了对比：
emm，我们仔细分析一下这个表：
DBTNet-50 在100% 数据时准确率 86.04%，作者的：SAM ResNet-50 时81.26，说明了resnet 和DBTNet 差距较大；作者的SAM bilinear（线性版本）：81.86%，说明了线性版本普遍比原始版本好；另外作者在DBTNet基础上，加上了SAM注意力，达到了87.26%的准确率，提升了1.22%，还凑合，不过在数据量仅有10%时，却比DBTNet提高了4%，说明了这个SAM在小数据情况更好。
这是网络的注意力可视化
可以看到这个工作的方法远好于Resnet50学到的，也好于FBP方法。
我们做工程的，不要被论文世界迷惑了，年轻人，你把握不住的。比如，这篇工作我刚刚说到100%数据时提高了1%左右，那么他的Flops带来了多少的增长，他的速度带来了多少的下降呢？接下来，我们一起来看看代码，看看是否适合我们~
如果是打比赛，那无脑上，精度有提高就行，很多比赛不限制时间得分，我也是拿过很多比赛奖的老玩家了，比赛堆砌和工程优化，和学术优化，是不一样滴~ 不过以前我打的天池万人赛，和其他平台的比赛，还是有时间得分的哦~
代码解读
首先，SAM模块是串联在你的Backbone后的，不像其他注意力机制是在卷积后的。他的Flops上升并不高。可以接受。
class SAM(nn.Module):
def __init__(self, network, backbone, projector_dim=1024, class_num=200, pretrained=True,
pretrained_path=None):
"""
network: the network of the backbone
backbone: the name of the backbone
feature_dim: the dimension of the output from the backbone
class_num: the class number of the dataset
pretrained: loading from pre-trained model or not (default: True)
pretrained_path: the path of the pre-trained model
"""
super(SAM, self).__init__()
self.class_num = class_num
self.backbone = backbone
self.pretrained = pretrained
self.pretrained_path = pretrained_path
# create the encoders
self.encoder = network(projector_dim=projector_dim)
self.load_pretrained(network)
self.conv16 = nn.Conv2d(512, 16, kernel_size=1, stride=1, padding=0,
bias=False)
self.bn16 = nn.BatchNorm2d(16)
self.bncbp = nn.BatchNorm1d(500)
self.bncbp.bias.requires_grad_(False)
nn.init.constant_(self.bncbp.weight, 1)
nn.init.constant_(self.bncbp.bias, 0)
self.mcb = CompactBilinearPooling(512, 16, 500).cuda()
self.relu = nn.ReLU(inplace=True)
self.avgpool = nn.AvgPool2d(7, stride=1)
def forward(self, im_q):
q_c, q_f, featmap_q = self.encoder_q(im_q)
# print()
featcov16 = self.conv16(featmap_q)
featcov16 = self.bn16(featcov16)
# bp————————————————————————
feat_matrix = torch.zeros(featcov16.size(0), 16, 512)
for i in range(16):
matrix = featcov16[:, i, :, :]
matrix = matrix[:, None, :, :]
matrix = matrix.repeat(1, 512, 1, 1)
PFM = featmap_q * matrix
aa = self.avgpool(PFM)
feat_matrix[:, i, :] = aa.view(aa.size(0), -1)
bp_out_feat = feat_matrix.view(feat_matrix.size(0), -1)
'''
#CBP
cbp_dim = 500
N,C1,H,W = featcov16.shape
_,C2,_,_ = featmap_q.shape
feat_part = featcov16.clone().permute(0,2,3,1).contiguous().view(-1,C1)
feat_whole = featmap_q.clone().permute(0,2,3,1).contiguous().view(-1,C2)
bp_out_feat = self.mcb(feat_whole.cuda(), feat_part.cuda())
bp_out_feat = bp_out_feat.view(N,H,W,cbp_dim).permute(0,3,1,2).contiguous()
bp_out_feat = bp_out_feat.view(N,cbp_dim,-1).sum(-1)
bp_out_feat = self.bncbp(bp_out_feat.cuda())
'''
return q_f, featmap_q, featcov16, bp_out_feat
def load_pretrained(self, network):
if 'resnet' in self.backbone:
q = network(projector_dim=1000, pretrained=self.pretrained)
# temp =q.fc
self.encoder_q = q
# self.encoder_q.fc = nn.Linear(in_features=2048, out_features= 1000, bias=True)
# print()
def inference(self, img):
y, feat, featmap = self.encoder_q(img)
featcov16 = self.conv16(featmap)
featcov16 = self.bn16(featcov16)
featcov16 = self.relu(featcov16)
feat_matrix = torch.zeros(featcov16.size(0), 16, 512)
for i in range(16):
matrix = featcov16[:, i, :, :]
matrix = matrix[:, None, :, :]
matrix = matrix.repeat(1, 512, 1, 1)
PFM = featmap * matrix
aa = self.avgpool(PFM)
feat_matrix[:, i, :] = aa.view(aa.size(0), -1)
bp_out_feat = feat_matrix.view(feat_matrix.size(0), -1)
'''
# CBP
cbp_dim = 500
N, C1, H, W = featcov16.shape
_, C2, _, _ = featmap_q.shape
feat_part = featcov16.clone().permute(0, 2, 3, 1).contiguous().view(-1, C1)
feat_whole = featmap_q.clone().permute(0, 2, 3, 1).contiguous().view(-1, C2)
bp_out_feat = self.mcb(feat_whole.cuda(), feat_part.cuda())
bp_out_feat = bp_out_feat.view(N, H, W, cbp_dim).permute(0, 3, 1, 2).contiguous()
bp_out_feat = bp_out_feat.view(N, cbp_dim, -1).sum(-1)
bp_out_feat = self.bncbp(bp_out_feat.cuda())
'''
# return bp_out_feat, featcov16
return feat.cuda(), featcov16
这边是SAM的模块细节，
class BaseCAM:
def __init__(self,
model,
target_layers,
use_cuda=False,
reshape_transform=None,
compute_input_gradient=False,
uses_gradients=True):
self.model = model.eval()
self.target_layers = target_layers
self.cuda = use_cuda
if self.cuda:
self.model = model.cuda()
self.reshape_transform = reshape_transform
self.compute_input_gradient = compute_input_gradient
self.uses_gradients = uses_gradients
self.activations_and_grads = ActivationsAndGradients(
self.model, target_layers, reshape_transform)
""" Get a vector of weights for every channel in the target layer.
Methods that return weights channels,
will typically need to only implement this function. """
def get_cam_weights(self,
input_tensor,
target_layers,
target_category,
activations,
grads):
raise Exception("Not Implemented")
def get_loss(self, output, target_category):
loss = 0
for i in range(len(target_category)):
loss += output[1][target_category[i]]
# loss = loss + output[i][target_category[i]]
# loss = loss + output[i, target_category[i]]
return loss
def get_cam_image(self,
input_tensor,
target_layer,
target_category,
activations,
grads,
eigen_smooth=False):
global weights
weights = self.get_cam_weights(input_tensor, target_layer,
target_category, activations, grads)
weighted_activations = weights[:, :, None, None] * activations
if eigen_smooth:
cam = get_2d_projection(weighted_activations)
else:
cam = weighted_activations.sum(axis=1)
return cam
def forward(self, input_tensor, target_category=None, eigen_smooth=False):
if self.cuda:
input_tensor = input_tensor.cuda()
if self.compute_input_gradient:
input_tensor = torch.autograd.Variable(input_tensor,
requires_grad=True)
output = self.activations_and_grads(input_tensor)
if isinstance(target_category, int):
target_category = [target_category] * input_tensor.size(0)
if target_category is None:
output = output[0]
target_category = np.argmax(output.cpu().data.numpy(), axis=-1)
else:
assert(len(target_category) == input_tensor.size(0))
if self.uses_gradients:
self.model.zero_grad()
loss = self.get_loss(output, target_category)
loss.backward(retain_graph=True)
# In most of the saliency attribution papers, the saliency is
# computed with a single target layer.
# Commonly it is the last convolutional layer.
# Here we support passing a list with multiple target layers.
# It will compute the saliency image for every image,
# and then aggregate them (with a default mean aggregation).
# This gives you more flexibility in case you just want to
# use all conv layers for example, all Batchnorm layers,
# or something else.
cam_per_layer = self.compute_cam_per_layer(input_tensor,
target_category,
eigen_smooth)
return self.aggregate_multi_layers(cam_per_layer), weights
def get_target_width_height(self, input_tensor):
width, height = input_tensor.size(-1), input_tensor.size(-2)
return width, height
def compute_cam_per_layer(
self,
input_tensor,
target_category,
eigen_smooth):
activations_list = [a.cpu().data.numpy()
for a in self.activations_and_grads.activations]
grads_list = [g.cpu().data.numpy()
for g in self.activations_and_grads.gradients]
target_size = self.get_target_width_height(input_tensor)
cam_per_target_layer = []
# Loop over the saliency image from every layer
for target_layer, layer_activations, layer_grads in \\
zip(self.target_layers, activations_list, grads_list):
cam = self.get_cam_image(input_tensor,
target_layer,
target_category,
layer_activations,
layer_grads,
eigen_smooth)
scaled = self.scale_cam_image(cam, target_size)
cam_per_target_layer.append(scaled[:, None, :])
return cam_per_target_layer
def aggregate_multi_layers(self, cam_per_target_layer):
cam_per_target_layer = np.concatenate(cam_per_target_layer, axis=1)
cam_per_target_layer = np.maximum(cam_per_target_layer, 0)
result = np.mean(cam_per_target_layer, axis=1)
return self.scale_cam_image(result)
def scale_cam_image(self, cam, target_size=None):
result = []
for img in cam:
img = img - np.min(img)
img = img / (1e-7 + np.max(img))
if target_size is not None:
img = cv2.resize(img, target_size)
result.append(img)
result = np.float32(result)
return result
def forward_augmentation_smoothing(self,
input_tensor,
target_category=None,
eigen_smooth=False):
transforms = tta.Compose(
[
tta.HorizontalFlip(),
tta.Multiply(factors=[0.9, 1, 1.1]),
]
)
cams = []
for transform in transforms:
augmented_tensor = transform.augment_image(input_tensor)
cam = self.forward(augmented_tensor,
target_category, eigen_smooth)
# The ttach library expects a tensor of size BxCxHxW
cam = cam[:, None, :, :]
cam = torch.from_numpy(cam)
cam = transform.deaugment_mask(cam)
# Back to numpy float32, HxW
cam = cam.numpy()
cam = cam[:, 0, :, :]
cams.append(cam)
cam = np.mean(np.float32(cams), axis=0)
return cam
def __call__(self,
input_tensor,
target_category=None,
aug_smooth=False,
eigen_smooth=False):
# Smooth the CAM result with test time augmentation
if aug_smooth is True:
return self.forward_augmentation_smoothing(
input_tensor, target_category, eigen_smooth)
return self.forward(input_tensor,
target_category, eigen_smooth)
def __del__(self):
self.activations_and_grads.release()
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, exc_tb):
self.activations_and_grads.release()
if isinstance(exc_value, IndexError):
# Handle IndexError here...
print(
f"An exception occurred in CAM with block: exc_type. Message: exc_value")
return True
这是CAM的部分。
class CompactBilinearPooling(nn.Module):
"""
Compute compact bilinear pooling over two bottom inputs.
Args:
output_dim: output dimension for compact bilinear pooling.
sum_pool: (Optional) If True, sum the output along height and width
dimensions and return output shape [batch_size, output_dim].
Otherwise return [batch_size, height, width, output_dim].
Default: True.
rand_h_1: (Optional) an 1D numpy array containing indices in interval
`[0, output_dim)`. Automatically generated from `seed_h_1`
if is None.
rand_s_1: (Optional) an 1D numpy array of 1 and -1, having the same shape
as `rand_h_1`. Automatically generated from `seed_s_1` if is
None.
rand_h_2: (Optional) an 1D numpy array containing indices in interval
`[0, output_dim)`. Automatically generated from `seed_h_2`
if is None.
rand_s_2: (Optional) an 1D numpy array of 1 and -1, having the same shape
as `rand_h_2`. Automatically generated from `seed_s_2` if is
None.
"""
def __init__(self, input_dim1, input_dim2, output_dim,
sum_pool=True, cuda=True,
rand_h_1=None, rand_s_1=None, rand_h_2=None, rand_s_2=None):
super(CompactBilinearPooling, self).__init__()
self.input_dim1 = input_dim1
self.input_dim2 = input_dim2
self.output_dim = output_dim
self.sum_pool = sum_pool
if rand_h_1 is None:
np.random.seed(1)
rand_h_1 = np.random.randint(output_dim, size=self.input_dim1)
if rand_s_1 is None:
np.random.seed(3)
rand_s_1 = 2 * np.random.randint(2, size=self.input_dim1) - 1
self.sparse_sketch_matrix1 = Variable(self.generate_sketch_matrix(
rand_h_1, rand_s_1, self.output_dim))
if rand_h_2 is None:
np.random.seed(5)
rand_h_2 = np.random.randint(output_dim, size=self.input_dim2)
if rand_s_2 is None:
np.random.seed(7)
rand_s_2 = 2 * np.random.randint(2, size=self.input_dim2) - 1
self.sparse_sketch_matrix2 = Variable(self.generate_sketch_matrix(
rand_h_2, rand_s_2, self.output_dim))
if cuda:
self.sparse_sketch_matrix1 = self.sparse_sketch_matrix1.cuda()
self.sparse_sketch_matrix2 = self.sparse_sketch_matrix2.cuda()
def forward(self, bottom1, bottom2):
"""
bottom1: 1st input, 4D Tensor of shape [batch_size, input_dim1, height, width].
bottom2: 2nd input, 4D Tensor of shape [batch_size, input_dim2, height, width].
"""
assert bottom1.size(1) == self.input_dim1 and \\
bottom2.size(1) == self.input_dim2
batch_size, _, height, width = bottom1.size()
bottom1_flat = bottom1.permute(0, 2, 3, 1).contiguous().view(-1, self.input_dim1)
bottom2_flat = bottom2.permute(0, 2, 3, 1).contiguous().view(-1, self.input_dim2)
sketch_1 = bottom1_flat.mm(self.sparse_sketch_matrix1)
sketch_2 = bottom2_flat.mm(self.sparse_sketch_matrix2)
fft1 = afft.fft(sketch_1)
fft2 = afft.fft(sketch_2)
fft_product = fft1 * fft2
cbp_flat = afft.ifft(fft_product).real
cbp = cbp_flat.view(batch_size, height, width, self.output_dim)
if self.sum_pool:
cbp = cbp.sum(dim=1).sum(dim=1)
return cbp
@staticmethod
def generate_sketch_matrix(rand_h, rand_s, output_dim):
"""
Return a sparse matrix used for tensor sketch operation in compact bilinear
pooling
Args:
rand_h: an 1D numpy array containing indices in interval `[0, output_dim)`.
rand_s: an 1D numpy array of 1 and -1, having the same shape as `rand_h`.
output_dim: the output dimensions of compact bilinear pooling.
Returns:
a sparse matrix of shape [input_dim, output_dim] for tensor sketch.
"""
# Generate a sparse matrix for tensor count sketch
rand_h = rand_h.astype(np.int64)
rand_s = rand_s.astype(np.float32)
assert(rand_h.ndim == 1 and rand_s.ndim ==
1 and len(rand_h) == len(rand_s))
assert(np.all(rand_h >= 0) and np.all(rand_h < output_dim))
input_dim = len(rand_h)
indices = np.concatenate((np.arange(input_dim)[..., np.newaxis],
rand_h[..., np.newaxis]), axis=1)
indices = torch.from_numpy(indices)
rand_s = torch.from_numpy(rand_s)
sparse_sketch_matrix = torch.sparse.FloatTensor(
indices.t(), rand_s, torch.Size([input_dim, output_dim]))
return sparse_sketch_matrix.to_dense()这是作者论文里的线性模式。
写在最后
作者是几位华人学生，在阿德莱德大学和澳大利亚大学
这份码起码有20多个大Bug，包括有好几处的变量未定义就使用的，网络的输入输出对不上等等，并且连数据读取、数据下载部分都有问题........
cv君的Debug能力还算比较好的，在我花了一个晚上改了20多个bug后，亲妈都快不认识这份顶会的代码了，终于能跑了。
个人建议，大家不要碰这份代码，看看他的论文思路就行，他的Block可以拿出来看看，不要碰他的代码，不然你将拥有一份和cv君一样的高强的Debug能力。
本来昨天就写完文章了，就因为去看他的代码，导致晚了一天。。
本文的名字是：《最新开源 随插即用》SAM 自增强注意力深度解读与实践（附代码及分析）
看完代码，我想改名字：《论新出的顶会论文代码写得有多差》
最后，附上论文原文https://arxiv.org/pdf/2208.00617.pdf和代码链接：GitHub - GANPerf/SAM
如果大家对SAM，或者其他注意力机制感兴趣，可以和cv君联系，cv君比较熟悉注意力机制。
以上是关于怎样解读SAM密码文件的主要内容，如果未能解决你的问题，请参考以下文章