精华内容
下载资源
问答
  • 1. oauth2原始错误返回类型JSON格式为{"error": "invalid_token","error_description": "Invalid access token: 123123123"}2. 想要在返回的数据类型中加上一个字段3.源码中源码org.springframework.security.oauth2...

    1. oauth2原始错误返回类型

    JSON格式为

    {

    "error": "invalid_token",

    "error_description": "Invalid access token: 123123123"

    }

    2. 想要在返回的数据类型中加上一个字段

    3.源码中

    源码org.springframework.security.oauth2.provider.authentication.OAuth2AuthenticationProcessingFilter拦截器中doFilter方法拦截到请求,如果token验证错误,会执行catch方法:

    catch (OAuth2Exception failed) {

    SecurityContextHolder.clearContext();

    if (debug) {

    logger.debug("Authentication request failed: " + failed);

    }

    eventPublisher.publishAuthenticationFailure(new BadCredentialsException(failed.getMessage(), failed),

    new PreAuthenticatedAuthenticationToken("access-token", "N/A"));

    authenticationEntryPoint.commence(request, response,

    new InsufficientAuthenticationException(failed.getMessage(), failed));

    return;

    }

    其中语句

    authenticationEntryPoint.commence(request, response,

    new InsufficientAuthenticationException(failed.getMessage(), failed));

    是接收token验证错误,但是实例authenticationEntryPoint是在类中new出来的

    private AuthenticationEntryPoint authenticationEntryPoint = new OAuth2AuthenticationEntryPoint();

    想要重写OAuth2AuthenticationEntryPoint类该怎么实现呢?

    在配置文件中改bean的注入类不起作用。

    展开全文
  • 1.加载bert模型及分词 from transformers import AutoModelForMaskedLM, AutoTokenizer model = "bert-base-cased" tokenizer = AutoTokenizer.from_pretrained(model, use_fast=True) model = AutoModelForMaskedLM...

    1.加载bert模型及分词

    from transformers import AutoModelForMaskedLM, AutoTokenizer
    model = "bert-base-cased"
    tokenizer = AutoTokenizer.from_pretrained(model, use_fast=True)
    model = AutoModelForMaskedLM.from_pretrained(model)
    

    2.分词演示

    • 这里是对COVID hospitalization分词
    print(tokenizer.tokenize('COVID'))
    print(tokenizer.tokenize('hospitalization'))
    ['CO', '##VI', '##D']
    ['hospital', '##ization']
    
    • 如果让着两个词都能保持完整,而不被拆分,进行如下操作
    # Let's increase the vocabulary of Bert model and tokenizer
    
    new_tokens = ['COVID', 'hospitalization']
    num_added_toks = tokenizer.add_tokens(new_tokens)
    
    # Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer.
    
    model.resize_token_embeddings(len(tokenizer))
    print(tokenizer.tokenize('COVID'))
    print(tokenizer.tokenize('hospitalization'))
    
    # with each new word added, a new vector of embeddings 
    # with random values was added as well thanks to the 
    # model.resize_token_embeddings(len(tokenizer)) method.
    
    tokenizer.savepretrained("modle_dir")
    

    3.自定义bert词表

    • bert有自己的vocab配置可以人为修改以适应下游任务,参考看这篇https://blog.csdn.net/kyle1314608/article/details/10661204

    • bert词表相关配置文件介绍
      https://www.jianshu.com/p/a6170d3408f5

    参考链接

    https://zhuanlan.zhihu.com/p/391814780

    展开全文
  • 客户端模式验证token

    2021-05-26 11:45:28
    客户端模式验证token (A)客户端向认证服务器进行身份认证,并要求一个访问令牌。  向服务器发送请求,附带信息进行身份校验,校验通过后返回一个令牌。 (B)认证服务器确认无误后,向客户端提供访问令牌。 获取...

    客户端模式验证token

    (A)客户端向认证服务器进行身份认证,并要求一个访问令牌。
     向服务器发送请求,附带信息进行身份校验,校验通过后返回一个令牌。

    (B)认证服务器确认无误后,向客户端提供访问令牌。

    获取token

    • 获取token
    # -*- coding: utf-8 -*-
    from odoo import http, fields
    from odoo.http import request
    from odoo.http import HttpRequest
    import traceback
    import json
    import hashlib
    import datetime
    import base64
    # 导入解码方法
    # from .zicthr_RSA import rsaDecryptStr
    from .zicthr_crypto_rsa import decrypt_data
    import logging
    _logger = logging.getLogger(__name__)
    
    
    class Authentication(http.Controller):
    
        def resp(self, ret_dict):
            headers = [
                ('Access-Control-Allow-Origin', '*'),
                ('Cache-Control', 'no-store'),
                ('Content-Type', 'application/json;charset=UTF-8')
            ]
            response = request.make_response(json.dumps(ret_dict, ensure_ascii=False), headers)
            #         response.headers['Content-Type'] = 'application/json'
            return response
    
    
        def check_error(self, errcode=40001, sub_msg=None):
            '''
    
            :param errcode:
            # ======================================
            # ** 40001: 数据库无匹配的token
            # ** 40002: 数据库中的token超时过期失效
            # ** 40003: 请求参数缺失
            # ** 40004: 未经许可的访问
            # ** 40005: 数据库中无匹配的用户或员工
            # ** 40006: 参数异常
            # ** 50001: 其他的错误
            # ======================================
            :param sub_msg:
            :return:
            '''
            if errcode == 40001:
                sub_msg = '不合法的token'
            elif errcode == 40002:
                sub_msg = 'token已过期'
            elif errcode == 40003:
                sub_msg = sub_msg or '参数不完整'
            elif errcode == 40004:
                sub_msg = sub_msg or '未经许可的访问'
            elif errcode == 40005:
                sub_msg = sub_msg or '无效的用户'
            elif errcode == 40006:
                sub_msg = sub_msg or '参数异常'
            elif errcode == 50001:
                sub_msg = sub_msg or '未知的错误'
            # data, msg,status
            result = {
                'data': {
                    'error_code': errcode,
                    'sub_msg': sub_msg,
                    'error_msg': 'check token error[errcode=%s,sub_msg=%s]' % (errcode, sub_msg)
                },
                'msg': 'check token error[errcode=%s,sub_msg=%s]'%(errcode, sub_msg),
                'status': str(errcode)
            }
    
            return self.resp(result)
    
        # 停用,启用时将csrf改为False(未更新)
        @http.route('/token/v1', type="http", methods=['GET'], auth="none", csrf=True)
        def token_v1(self, **kw):
            '''
            客户端模式认证
            :httprequest.data:
                {
                    "response_type": "token",
                    "systemCode": "DingTalk",
                    "client_id": DING_XXXX_APP -> base64 -> "string",
                    "empNum": hr.employee .num
                }
            :return:
            success:
                result = {
                    "access_token": token_str,
                    "token_type": "auth_ding",
                    "expires_in": 3600,
                }
            error:
                check_error():
                    result = {
                        'error_code': errcode,
                        'sub_msg': sub_msg,
                        'error_msg': 'check token error[errcode=%s,sub_msg=%s]'%(errcode, sub_msg)
                    }
            '''
            response_type = kw.get('response_type')
            systemCode = kw.get('systemCode')  # DingTalk
            client_id = kw.get('client_id')  # base64
            empNum = kw.get('empNum')
            if not (response_type and systemCode and client_id and empNum):
                msg = '缺少参数'
                return self.check_error(40003, msg)
            if response_type == 'token':
                pass
            try:
                client_code = base64.b64decode(client_id)
                client_code = client_code.decode('utf-8')
            except:
                _logger.error('check token client_code base64 decode error.')
                return self.check_error(50001)
            if not (systemCode == 'DingTalk' and client_code == 'DING_XXXX_APP'):  # 客户端标识不匹配
                msg = '未经许可的系统标识'
                return self.check_error(40004, msg)
            emp_obj = request.env['hr.employee']
            user_obj = request.env['res.users']
            emp_id = emp_obj.sudo().search([('num', '=', empNum), ('status', '!=', 'leave')])
            user_id = user_obj.sudo().search([('login', '=', empNum), ('active', '=', True)])
            if not (emp_id and user_id):  # 无匹配用户
                return self.check_error(40005, '无效的用户%s'%empNum)
                # return self.check_error(40005)
            token_text = 'xxxx' + empNum + systemCode + datetime.datetime.strftime(datetime.datetime.now(), '%Y%m%d%H')
            token_str = hashlib.sha1(token_text.encode('utf-8')).hexdigest()
            result = {
                "access_token": token_str,
                "token_type": "auth_ding",
                "expires_in": 3600,
            }
            response = self.resp(result)
            create_token = {
                'token': token_str,
                'employee_id': emp_id.id
            }
            token_obj = request.env['hr.token']
            token_ids = token_obj.sudo().search([('employee_id', '=', emp_id.id)])
            if token_ids:
                create_token['last_connect_time'] = fields.Datetime.now()
                token_ids.sudo().write(create_token)
            else:
                token_obj.sudo().create(create_token)
            return response
    
    
        @http.route('/token', type="http", methods=['POST'], auth="none", csrf=False)
        def token(self):
            '''
            客户端模式认证
            :httprequest.data:
                {
                    "response_type": "token",
                    "systemCode": "DingTalk",
                    "client_id": DING_XXXX_APP -> base64 -> "string",
                    "empNum": hr.employee .num : 经rsa加密, 需要在服务端进行解密
                }
            :return:
            success:
                result = {
                    "access_token": token_str,
                    "token_type": "auth_ding",
                    "expires_in": 3600,
                }
            error:
                check_error():
                    result = {
                        'error_code': errcode,
                        'sub_msg': sub_msg,
                        'error_msg': 'check token error[errcode=%s,sub_msg=%s]'%(errcode, sub_msg)
                    }
            '''
            data = request.httprequest.data
            content = json.loads(data.decode())
            systemCode = content.get('systemCode')  # DingTalk
            client_id = content.get('client_id')  # base64
            empNum = content.get('empNum')
            response_type = content.get('response_type')
            if not (response_type and systemCode and client_id and empNum):
                msg = '缺少参数'
                return self.check_error(40003, msg)
            if response_type == 'token':
                pass
            try:
                client_code = base64.b64decode(client_id)
                client_code = client_code.decode('utf-8')
            except:
                _logger.error('check token client_code base64 decode error.')
                return self.check_error(50001)
            # print(client_code)
            if not (systemCode == 'DingTalk' and client_code == 'DING_XXXX_APP'):  # 客户端标识不匹配
                msg = '未经许可的系统标识'
                return self.check_error(40004, msg)
            # 解码empNum
            try:
                empNum = decrypt_data(empNum)
                # empNum = rsaDecryptStr(empNum)
            except:
                _logger.error(traceback.format_exc())
                _logger.error('获取token接口解码异常...')
                return self.check_error(40006)
            emp_obj = request.env['hr.employee']
            user_obj = request.env['res.users']
            emp_id = emp_obj.sudo().search([('num', '=', empNum), ('status', '!=', 'leave')])
            user_id = user_obj.sudo().search([('login', '=', empNum), ('active', '=', True)])
            if not (emp_id and user_id):  # 无匹配用户
                return self.check_error(40005, '无效的用户%s'%empNum)
                # return self.check_error(40005)
            token_text = 'xxxx' + empNum + systemCode + datetime.datetime.strftime(datetime.datetime.now(), '%Y%m%d%H')
            token_str = hashlib.sha1(token_text.encode('utf-8')).hexdigest()
            result = {
                'data': {
                    "access_token": token_str,
                    "token_type": "auth_ding",
                    "expires_in": 3600,
                },
                'msg': '校验成功',
                'status': '1'
            }
            response = self.resp(result)
            create_token = {
                'token': token_str,
                'employee_id': emp_id.id
            }
            token_obj = request.env['hr.token']
            token_ids = token_obj.sudo().search([('employee_id', '=', emp_id.id)])
            if token_ids:
                create_token['last_connect_time'] = fields.Datetime.now()
                token_ids.sudo().write(create_token)
            else:
                token_obj.sudo().create(create_token)
            return response
    
    

    token模型及token校验

    • token模型及token校验
    # -*- coding: utf-8 -*-
    
    from odoo import models, fields, api, exceptions
    import traceback
    import logging
    import datetime
    from dateutil.relativedelta import relativedelta
    _logger = logging.getLogger(__name__)
    
    
    class hr_token(models.Model):
        # 私有属性:(_name, _description, _inherit, …)
        _name = 'hr.token'
        _description = 'Authentication Token'
        _order = ''
    
        # 默认方法和 _default_get
    
        # Field 字段声明
        employee_id = fields.Many2one('hr.employee', string='Employee')
        employee_name = fields.Char(string='Employee Name', related='employee_id.name')
        employee_num = fields.Char(string='Employee Num', related='employee_id.num')
        token = fields.Char(string='Token')
        last_connect_time = fields.Datetime(string='Last Connect', default=lambda self:fields.Datetime.now())
        is_active = fields.Boolean(string=u'是否有效', compute='_compute_is_active')
    
    
        # Compute, inverse and search 等计算和搜索方法和字段声明顺序一致
        @api.multi
        def _compute_is_active(self):
            for record in self:
                if record.last_connect_time:
                    if record.last_connect_time >= fields.Datetime.now() - relativedelta(hours=1):
                        record.is_active = True
                    else:
                        record.is_active = False
                else:
                    record.is_active = False
    
        # Selection 方法(返回 selection 字段的列表值)
    
        # Constrains 约束方法(@api.constrains) and onchange 字段值变更方法 (@api.onchange)
        _sql_constraints = [('token_unq', 'unique(token)', u'token必须唯一!'), ('employee_unq', 'unique(employee_id)', u'员工必须唯一!'), ]
    
        # CRUD方法(ORM 覆盖与继承)
    
        # Action方法
    
        # 其他业务方法
        @api.model
        def auth_token(self, token):
            '''
            校验token是否匹配, 是否过期
            :param token:
            :return:
                1. 校验通过: 返回 True, 员工对象
                2. 校验不通过: 返回False, 异常状态码
                    异常状态码: 40001【无匹配的token】/40002【token过期失效】
            '''
            record = self.sudo().search([('token', '=', token)])
            if not record:
                return False, 40001
            r = record[0]
            if r.is_active:
                r.last_connect_time = fields.Datetime.now()
                return True, r.employee_id
            else:
                return False, 40002
        
    
    展开全文
  • 【解析】Token to Token Vision Transformer

    千次阅读 2021-04-18 14:20:42
    的提出让我们看到了Transformer模型在图像方向的潜力,但其有一些缺点,如需要超大型数据集(JFT)预训练,才能达到现在CNN的精度。本文分析了ViT的一些不合理之处: 直接将图片分块展开成一维向量 不利于对图片...

    在这里插入图片描述

    Vision Transformer 的提出颠覆了我们以往对图像处理的方式,也开阔了Transformer 在CV方向上的潜力,但其有一些缺点,如需要 超大型数据集(JFT)预训练,才能达到现在CNN的精度。本文分析了ViT的一些不合理之处:

    • 直接将图片分块展开成一维向量 不利于对图片结构信息(如边缘,线条)建模
    • 冗余的Attention模块限制了特征表达,并带来运算负担

    基于上述两点,本文提出Tokens to Token Transformer,采用类似CNN中卷积划窗的方式,将相邻的tokens局部聚合起来,有助于建模局部特征。另外还设计了一种deep narrow(个人理解是 深+窄 的网络结构)结构,减少了运算量,并获得性能上的提升。


    1、特征可视化分析

    在这里插入图片描述

    本文先分析了Resnet50,Vision Transformer,T2T Transformer的特征可视化。其中绿框标注的是浅层特征,如边缘,线条。红框标注的是一些零值或过大值。

    我们先从熟悉的CNN看起,在比较浅的层中,网络学习到的更多是结构信息,比如对这只小狗边缘的刻画。随着层数加深,通道数变深,特征也越来越抽象

    再来看ViT,他每层都能很好的建模全局信息,即使是很深的层当中,也没有所谓非常抽象的东西。但它对结构信息捕捉的很少,(个人认为是没有类似CNN卷积核划窗的操作,导致对局部信息捕捉不够?)。除此之外,在一些特征图出现了极值,如全白和全黑的特征,对于最终预测可能是没有贡献的。

    最后看下T2T,通过Token to Token结构(下文会讲),它在浅层的时候也能建模出结构信息,同时也避免了极值的出现。


    2、Token to Token 结构

    在这里插入图片描述

    Vision Transformer是将二维图片展平成一维向量(也叫token),然后送入到Transoformer结构里。而T2T为了捕捉局部信息,它将所有的token通过reshape操作,恢复成二维,然后利用一个unfold一个划窗操作,属于一个窗口的tokens,会连接成一个更长的token,然后送入到Transformer中。

    这样会逐渐减少token的数量,但随之而来token的长度会增加很多(因为多个tokens连接在一个token),因此后续模型也降低了维度数目,以平衡计算量。


    3、Unfold操作

    Unfold操作其实就是卷积中用到的img2col方法,将一个卷积窗口的向量,重排成一个列向量。

    下面是一段测试代码

    import torch
    import numpy as np
    
    np_input = np.array([[[[1, 2, 3],
                           [4, 5, 6],
                           [7, 8, 9]],
                         [[10, 11, 12],
                          [13, 14, 15],
                          [16, 17, 18]],
                         [[19, 20, 21],
                          [22, 23, 24],
                          [25, 26, 27]],
                         [[28, 29, 30],
                          [31, 32, 33],
                          [34, 35, 36]]]]).astype(np.float32)
    
    torch_input = torch.Tensor(np_input)
    
    unfold = torch.nn.Unfold(kernel_size=2, padding=0, stride=1)
    unfolded = unfold(torch_input)
    
    print(unfolded)
    
    # 输出为
    

    示意图

    在这里插入图片描述


    4、整体架构

    在这里插入图片描述

    T2T架构如上图所示,先经过2次Tokens to Token操作,最后给token加入用于图像分类的cls token,并给上位置编码(position embedding),送入到Backbone当中。


    5、Backbone设计探索

    现今CNN探索出了很多结构,比如Resnet残差结构,DenseNet密集连接,GhostNet生成冗余特征,SE注意力模块,ResNext多头分组卷积等。作者基于这些思想进行了一系列模型设计,实验,最终结论如下

    • 更深更窄(Deep Narrow)的ViT结构比更浅更宽(Shallow Wide )的性能更好
    • DenseNet的密集concat结构均使ViT和T2T-ViT性能下降
    • SE注意力模块 均能提升ViT和T2T-ViT的性能
    • ResNext结构对于ViT和T2T-ViT的 性能提升很微弱
    • GhostNet结构可以 进一步压缩模型大小,但同样会损失一定性能 基于上述实验,作者选择了Deep Narrow的结构形式

    在这里插入图片描述



    6、代码解读

    Token Transformer
    整体结构很简单,输入经过一次LayerNorm,然后输入到Attention多头注意力模块。输出再次经过LayerNorm,最后设置一定比例的Dropout

    class Token_transformer(nn.Module):
    
        def __init__(self, dim, in_dim, num_heads, mlp_ratio=1., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
                     drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm):
            super().__init__()
            self.norm1 = norm_layer(dim)
            self.attn = Attention(
                dim, in_dim=in_dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
            self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
            self.norm2 = norm_layer(in_dim)
            self.mlp = Mlp(in_features=in_dim, hidden_features=int(in_dim*mlp_ratio), out_features=in_dim, act_layer=act_layer, drop=drop)
    
        def forward(self, x):
            x = self.attn(self.norm1(x))
            x = x + self.drop_path(self.mlp(self.norm2(x)))
            return x
    

    T2T Module

    首先设置三个划窗大小分别为7x7, 3x3, 3x3的Unfold操作,和两个Token Transformer模块。

    • 假设输入数据格式是: N ∗ C ∗ H ∗ W N*C*H*W NCHW
    • 在forward中,先进行一次soft_split操作,数据变为: N ∗ C ′ ∗ K N*C'*K NCK
    • 然后进行一次transpose操作,将通道维调整到最后一维度: N ∗ K ∗ C ′ N*K*C' NKC
    • 送入到Attention模块后,再把通道维调整回来: N ∗ C ′ ∗ K N*C'*K NCK
    • 最后reshape成4维数据: N ∗ C ′ ∗ n e w _ H W ∗ n e w _ H W N*C'*new\_HW*new\_HW NCnew_HWnew_HW

    再重复上述类似的步骤,最后经过一个全连接层,调整通道数到合适的Embedding dim。

    class T2T_module(nn.Module):
        """
        Tokens-to-Token encoding module
        """
    
        def __init__(self, img_size=224, tokens_type='performer', in_chans=3, embed_dim=768, token_dim=64):
            super().__init__()
    
            if tokens_type == 'transformer':
                print('adopt transformer encoder for tokens-to-token')
                self.soft_split0 = nn.Unfold(kernel_size=(7, 7), stride=(4, 4), padding=(2, 2))
                self.soft_split1 = nn.Unfold(kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
                self.soft_split2 = nn.Unfold(kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
    
                self.attention1 = Token_transformer(dim=in_chans * 7 * 7, in_dim=token_dim, num_heads=1, mlp_ratio=1.0)
                self.attention2 = Token_transformer(dim=token_dim * 3 * 3, in_dim=token_dim, num_heads=1, mlp_ratio=1.0)
                self.project = nn.Linear(token_dim * 3 * 3, embed_dim)
    
            elif tokens_type == 'performer':
                ...
            elif tokens_type == 'convolution':  # just for comparison with conolution, not our model
                # for this tokens type, you need change forward as three convolution operation
                ...
            self.num_patches = (img_size // (4 * 2 * 2)) * (
                        img_size // (4 * 2 * 2))  # there are 3 sfot split, stride are 4,2,2 seperately
        def forward(self, x):
            # step0: soft split
            x = self.soft_split0(x).transpose(1, 2)
    
            # iteration1: restricturization/reconstruction
            x = self.attention1(x)
            B, new_HW, C = x.shape
            x = x.transpose(1, 2).reshape(B, C, int(np.sqrt(new_HW)), int(np.sqrt(new_HW)))
            # iteration1: soft split
            x = self.soft_split1(x).transpose(1, 2)
    
            # iteration2: restricturization/reconstruction
            x = self.attention2(x)
            B, new_HW, C = x.shape
            x = x.transpose(1, 2).reshape(B, C, int(np.sqrt(new_HW)), int(np.sqrt(new_HW)))
            # iteration2: soft split
            x = self.soft_split2(x).transpose(1, 2)
    
            # final tokens
            x = self.project(x)
    
            return x
    

    T2T ViT 整体结构代码

    整个架构是将输入数据通过T2Tmodule,然后设立一个分类的token(cls_tokens),将其concat到x中,并加入position embedding(这里是用一个可学习参数作为位置编码)。处理好后,输入到一个个叠起来的Transformer Block,最后取第一个token(也就是cls_tokens),输入到分类层,得到最终结果。

    class T2T_ViT(nn.Module):
        def __init__(self, img_size=224, tokens_type='performer', in_chans=3, num_classes=1000, embed_dim=768, depth=12,
                     num_heads=12, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop_rate=0., attn_drop_rate=0.,
                     drop_path_rate=0., norm_layer=nn.LayerNorm):
            super().__init__()
            self.num_classes = num_classes
            self.num_features = self.embed_dim = embed_dim  # num_features for consistency with other models
    
            self.tokens_to_token = T2T_module(
                img_size=img_size, tokens_type=tokens_type, in_chans=in_chans, embed_dim=embed_dim)
            num_patches = self.tokens_to_token.num_patches
    
            self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
            self.pos_embed = nn.Parameter(data=get_sinusoid_encoding(n_position=num_patches + 1, d_hid=embed_dim),
                                          requires_grad=False)
            self.pos_drop = nn.Dropout(p=drop_rate)
    
            dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]  # stochastic depth decay rule
            self.blocks = nn.ModuleList([
                Block(
                    dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
                    drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer)
                for i in range(depth)])
            self.norm = norm_layer(embed_dim)
    
            # Classifier head
            self.head = nn.Linear(embed_dim, num_classes) if num_classes > 0 else nn.Identity()
    
            trunc_normal_(self.cls_token, std=.02)
            self.apply(self._init_weights)
    
        ...忽略一些其他的方法
    
        def forward_features(self, x):
            B = x.shape[0]
            x = self.tokens_to_token(x)
    
            cls_tokens = self.cls_token.expand(B, -1, -1)
            x = torch.cat((cls_tokens, x), dim=1)
            x = x + self.pos_embed
            x = self.pos_drop(x)
    
            for blk in self.blocks:
                x = blk(x)
    
            x = self.norm(x)
            return x[:, 0]
    
        def forward(self, x):
            x = self.forward_features(x)
            x = self.head(x)
            return x
    

    总结

    依图科技近期也开源了相关代码 yitu-opensource/ T2T-ViT,大家有兴趣的话可以试验下代码。

    个人感觉这篇论文还是偏工程化的,通过分析初版Vision Transformer的缺点,提出T2T结构,并且在BackBone上,以CNN的视角重新探索,将CNN的优点结合起来,最终效果也是十分不错的,期待后续CNN结合Transformer的相关工作。

    展开全文
  • token与用户权限-前端权限控制-RBAC模型 目录 文章目录1、登录和token携带1.1、 登录2、用户信息(权限信息)获取和存储***后记*** : 内容 完整的权限控制包括后端和前端,这里我们先分析下前端。 1、登录和...
  • 这是因为config/app.php文件中,用户模型没设置,默认是User,我用的模型是Students所以需要重新设置一下,然后重启项目(必须重启才行!) 'guards' => [ 'web' => [ 'driver' => 'session', '...
  • 1.打开 database/migrations/2014_10_12_000000_create_users_...我们需要为 user 表添加 api_token 字段, 也就是说我们的 token 是保存在数据库中的, 在合适的位置, 添加一行$table->string('api_token', 60...
  • 字节跳动 Xinsong Zhang、李航两位研究者在细粒度和粗粒度标记化的基础上,提出了一种新的预训练语言模型,他们称之为 AMBERT(一种多粒度 BERT)。在构成上,AMBERT 具有两个编码器。 预训练语言模型如BERT...
  • 因此提出一种Hierarchical Visual Transformer,采用渐进的池化token压缩序列长度,减少计算损失,类似于CNN中的特征图下采样,本文没有采用class token ,而是采用平均池化代替单一的class token,实验表明,平均...
  • 小程序-登录-token

    2021-08-06 09:37:14
    1.前端调用wx.login()获取code值2....服务器通过code请求api--auth.code2Session,换回session_key和openid示例代码(判断用户的openid是否在数据库中不在就加入成为会员,再给前端发送token(随机字符,也可...
  • 1 从语音识别说起语音识别是什么,通俗来说,就是输入音频,输出识别文字结果。...等式右边是两项乘积,P(W)来自语言模型(Language Model, LM), 常用的模型有 N-gram。 P(O | W)来自于声学模型(Acousti...
  • VIT中特殊class token的一些问题

    千次阅读 2021-12-03 21:02:35
    类似于BERT中的[class] token,ViT引入了class token机制,其目的:因为transformer输入为一系列的patch embedding,输出也是同样长的序列patch feature,但是最后要总结为一个类别的判断,简单方法可以用avg pool,...
  • Laravel 在登录返回Token

    2021-04-24 23:21:11
    这里使用JWT来实现token,比较方便简单。关于JWT的引入以及配置可以查看这篇文章,里面有Laravel接入JWT的全面方法,照做即可。方法最后变成/** 密码登录* */public function pwdLogin(PwdLoginRequest $...
  • 微信小程序登录换取token的教程来源:中文源码网浏览: 次日期:2018年9月2日【下载文档:微信小程序登录换取token的教程.txt】(友情提示:右键点上行txt文档名->目标另存为)微信小程序登录换取token的教程 前言:...
  • 令牌概述(Token) 在以用户账号体系作为安全认证的信息系统中,对用户身份的鉴定是非常重要的事情。 令牌机制是软件系统安全体系中非常重要的部分,在计算机身份认证中是令牌的意思,一般作为邀请、登录...
  • Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准((RFC 7519).定义了一种简洁的,自包含的方法用于通信双方之间以JSON对象的形式安全的传递信息。因为数字签名的存在,这些信息...
  • 首先,在token验证模块中,我们看到的是这一函数: def get_model(self): if self.model is not None: return self.model from rest_framework.authtoken.models import Token return Token 这里我们先不看...
  • 前后端分离以及token的使用为什么使用前后端分离:首先说一下jsp的工作原理:jsp实际上也是是一个继承自Servlet接口的java类,实际上它就是一个Servlet,JSP的页面渲染是在后端完成的,经过tomcat的处理后,把jsp...
  • 前言:这次主要是介绍些业务逻辑,技术点...所谓落后就要挨打,那么今天就开始学习小程序的一些小知识吧(本文基于十年磨一剑的tp5)目录:微信登录换取token的流程如何将code变成openid和session_key抛出错误异常和...
  • JWT实现token验证

    2021-01-12 19:17:03
    什么是JWTJson web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准((RFC 7519).定义了一种简洁的,自包含的方法用于通信双方之间以JSON对象的形式安全的传递信息。因为数字签名的存在...
  • } /** * @param null $token * @return int|mixed * 验证token */ public static function verifyToken($token=null){ //检测是否接收到了token if(empty($token)){ return 0; } //转化为可以验证的token $token = ...
  • 生成一个唯一token

    2021-03-21 09:06:23
    Django之模型层-多表操作 多表操作 数据库表关系 一对多:两个表之间的关系一旦确定为一对多,必须在数据多的表中创建关联字段 多对多:两个表之间的关系一定确定为多对多,必须创建第三张表(关联表) 一对一:一旦两个表...
  • 深度学习中的token和tokenization

    千次阅读 2021-07-22 16:58:39
    在论文中出现了名词token,我无法对它做出很好的翻译,导致论文读不下去。网上对它的解释多种多样,经过查阅学习后,我的理解如下。 (我阅读的是英文文献,将其完全翻译成中文,并不能很好的帮助阅读,甚至能限制它...
  • Django 使用 token 认证

    2021-05-08 21:52:10
    token:适用于 web、app oauth:微信、QQ登录 目前在 django 中使用 session 认证的方式比较多,因为 django 内置了强大的用户认证系统–auth模块。 下面会结合 session 和 token 两种认证方式做一个登录的示例。 ...
  • 一.普通token校验 待续
  • django Token权限认证

    2021-03-29 11:44:10
    django Token权限认证 users.models.py # Create your models here. from rest_framework.authtoken.... 继承Token模型,方便后期扩展 """ class Meta: verbose_name = 'Private Token' users.authenticatio
  • 引语最近正好在独立开发一个后台管理系统,涉及到了基于Token的身份认证,自己边学边用边做整理和总结,对基于JWT实现的Token的身份认证做一次相对比较全面的认识。一、基于session的跨域身份验证Internet服务无法与...
  • Laravel API Token 体验

    2021-04-24 23:21:01
    适用laravel版本5.3+简介Laravel API 默认驱动为token,文档上没介绍如何使用,下面让我们来实现它。'api' => ['driver' => 'token','provider' => 'users',],配置字段项目下执行命令...
  • 使用python gensim轻松实现lda模型。gensim简介gemsim是一个免费python库,能够从文档中有效地自动抽取语义主题。gensim中的算法包括:LSA(Latent Semantic Analysis), LDA(Latent Dirichlet Allocation), RP ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 74,677
精华内容 29,870
关键字:

token模型