呆呆的猫

【Transformer】7、TNT: Transformer iN Transformer

文章目录

- 一、背景
- 二、动机
- 三、方法
- - 3.1 Transformer in Transformer
  - 3.2 Network Architecture
- 四、效果
- 五、代码

论文链接： Transformer in Transformer

代码链接：https://github.com/huawei-noah/CV-Backbones/tree/master/tnt_pytorch

一、背景

Transformer 是一种主要基于注意力机制的网络结构，能提取输入数据的特征。计算机视觉中的 Transformer 首先将输入图像均分为多个图像块，然后提取其特征和关系。因为图像数据有很多的细节纹理和颜色等信息，所以目前方法所分的图像块的粒度还不够细，以至于难以挖掘不同尺度和位置特征。

二、动机

计算机视觉使用的是图像作为输入，所以输入和输出在语义上有很大的 gap，所以 ViT 将图像分成了几块组成一个 sequence 作为输入，然后使用 attention 计算不同 patch 之间的关系，来生成图像特征表达。

虽然 ViT 及其变体能够较好的提取图像特征来实现识别的任务，但数据集中的图像是很多样的，虽然将图像分块能够很好的找到不同 patch 之间的关系和相似性，但不同图像块内的小图像块也存在很高的相似性。

作者受此启发，提出了一个更加精细的图像划分方法，来生成 visual sequence 并且提升效果。

三、方法

方法：

先将图像进行 patch 划分（sentence），每个 patch 加上位置编码，同样使用一个 cls_token
在每个 patch 内部，再次进行 words 的划分，给每个 words 也加上位置编码，patch 内部不需要使用 cls_token，得到了 patch 内部 words 的特征后，进行映射 LN → Linear 映射 → LN

本文中，作者指出，每个 patch 内部的 attention 对网络效果的影响是非常重要的，所以提出了一种新的结构 TNT。

将 patch（16x16）看做 “visual sentence”
将 patch 再切分成更细的 patch（4x4），看做 “visual words”
会计算 sentence 中每个 words 和其他 words 的 attention
然后把 sentences 和 words 的特征进行聚合来提高网络特征的表达能力
TNT 在 ImageNet 上达到了 81.5% 的 top-1 acc，比当前 SOTA 提升了 1.7%

3.1 Transformer in Transformer

1、输入 2D 图像，切分成 $n$ 个 patches

2、将每个 patch 切分成 $m$ 个 sub-patches， $x^{i,j}$ 是第 i 个 visual sentence 中的第 j 个word

3、对 visual sentence 和 visual word 分别进行处理

inner transformer block 用来对 word 之间建模，outer transformer block 捕捉 sentence 之间的关系。

通过对 TNT block 的 L 次堆叠，得到 transformer-in-transformer network。类似于 ViT，classification token 在这里也作为图像整体特征的表达。

① 对于 word embedding

使用线性映射将 visual word 进行 embedding，得到如下的 $Y$

使用 transformer 来抽取不同 words 之间的关系，L 是 block 的总数，第一个 block $Y_0^i$ 的输入是上面的 $Y^i$ 。

经过 transformer 之后，图像中的所有 word embedding 可以表示为 $Y_l=[Y_l^1, Y_l^2, ..., Y_l^n]$ ，这也可以看成一个内部 transformer block，叫做 $T_{in}$ ，这个过程给每个 sentence 内部的所有 word 两两之间建立了关系特征。

举例来说，就是在一个人脸图分割的patch中，一个眼睛对应的 word 和另外一个眼睛对应的 word 关联更高，而与前额关联更少一些。

② 对于 sentence embedding

作者建立了一个 sentence embedding memories 来存储 sentence 层面的序列表达， $Z_{class}$ 是 class token，用来分类：

在每一层 sentence embedding，会将 word embedding 的序列结果经过线性变换后加到 sentence embedding上， $W$ 和 $b$ 分别为权重和偏置

之后，使用标准的 transformer 来进行特征提取，即使用 outer transformer $T_{out}$ 来对不同的 sentence embedding 进行关系建模。

总之，TNT block 的输入和输出都包括了 word embedding 和 sentence embedding，如图1b所示，所以 TNT 总体表达如下：

3、position encoding

对于 word 和 sentence，分别都要使用位置编码来保持空间信息。作者在这里使用的是可学习的一维位置编码。

对于 sentence，每个 sentence 都被分配了一个位置编码， $E_{sentence}\in R^{(n+1)\times d}$ 是 sentence 位置编码。

对于sentence 中的 word，也给每个都加上了位置编码， $E_{word}$ 是 word 位置编码，所有 sentence 内的 word 编码是共享的。

3.2 Network Architecture

patch size：16x16
sun-patch size：m=4x4=16
TNT-S(Small, 23.8M) 和 TNT-B(Base, 65.6M) 的结构

四、效果

消融实验：

可视化：

1、特征图可视化

① DeiT 和 TNT 学习到的特征图可视化如下，第 1、6、12 个block 的特征图如图3a所示，TNT 的位置信息保存的更好。

图3b 使用 t-SNE 可视化了第 12 个 block 的所有 384 个 feature map，可以看出来 TNT 的特征图更加多样，保存了更丰富的信息，这可以归功于 inner transformer 对局部特征的建模能力。

② 除了 patch-level 外，作者还可视化了 pixel-level 的 embedding 如图4，对于每个 patch，作者根据空间位置进行了 reshape，然后把所有通道进行了平均。平均后的特征图大小为 14x14，可以看出在浅层局部特征保存的较好，深层特征越来越抽象。

2、Attention map 的可视化

在 TNT block 里边有两个不同的 self-attention，inner self-attention 和 outer self-attention，图5展示了 inner transformer 的不同 query 的 attention map。

① visual word 可视化

对于一个给定的 visual word，和该 visual word 想外观越相似的 word 的 attention value 越高，这也表示他们的特征将和 query 进行更密切的交互，但 ViT 和 DeiT 就没有这种特性。

② visual sentence 可视化

图6展示了某个 patch 对其他所有 patch 的 attention map，随着层的加深，更多的 patch 会有响应。这是因为在越深的层，patch 之间的信息会更好的被关联起来。

在 block-12，TNT 能够关注到有用的 patch，而 DeiT 仍然会关注到和 panda 无关的 patch 上去。

3、class token 和 patch 之间的 attention

图7可视化了 class token 和图像中的所有 patches 之间的关系，可以看出输出特征会更加注意到和目标位置关联的patch

五、代码

import torch
from tnt import TNT
tnt = TNT()
tnt.eval()
inputs = torch.randn(1, 3, 224, 224)
logits = tnt(inputs)

tnt.py 代码如下：


import torch
import torch.nn as nn
from functools import partial
import math

from timm.data import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
from timm.models.helpers import load_pretrained
from timm.models.layers import DropPath, to_2tuple, trunc_normal_
from timm.models.resnet import resnet26d, resnet50d
from timm.models.registry import register_model


def _cfg(url='', **kwargs):
    return {
        'url': url,
        'num_classes': 1000, 'input_size': (3, 224, 224), 'pool_size': None,
        'crop_pct': .9, 'interpolation': 'bicubic',
        'mean': IMAGENET_DEFAULT_MEAN, 'std': IMAGENET_DEFAULT_STD,
        'first_conv': 'patch_embed.proj', 'classifier': 'head',
        **kwargs
    }


default_cfgs = {
    'tnt_s_patch16_224': _cfg(
        mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5),
    ),
    'tnt_b_patch16_224': _cfg(
        mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5),
    ),
}


def make_divisible(v, divisor=8, min_value=None):
    min_value = min_value or divisor
    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
    # Make sure that round down does not go down by more than 10%.
    if new_v < 0.9 * v:
        new_v += divisor
    return new_v


class Mlp(nn.Module):
    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
        super().__init__()
        out_features = out_features or in_features
        hidden_features = hidden_features or in_features
        self.fc1 = nn.Linear(in_features, hidden_features)
        self.act = act_layer()
        self.fc2 = nn.Linear(hidden_features, out_features)
        self.drop = nn.Dropout(drop)

    def forward(self, x):
        x = self.fc1(x)
        x = self.act(x)
        x = self.drop(x)
        x = self.fc2(x)
        x = self.drop(x)
        return x


class SE(nn.Module):
    def __init__(self, dim, hidden_ratio=None):
        super().__init__()
        hidden_ratio = hidden_ratio or 1
        self.dim = dim
        hidden_dim = int(dim * hidden_ratio)
        self.fc = nn.Sequential(
            nn.LayerNorm(dim),
            nn.Linear(dim, hidden_dim),
            nn.ReLU(inplace=True),
            nn.Linear(hidden_dim, dim),
            nn.Tanh()
        )

    def forward(self, x):
        a = x.mean(dim=1, keepdim=True) # B, 1, C
        a = self.fc(a)
        x = a * x
        return x


class Attention(nn.Module):
    def __init__(self, dim, hidden_dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0.):
        super().__init__()
        self.hidden_dim = hidden_dim
        self.num_heads = num_heads
        head_dim = hidden_dim // num_heads
        self.head_dim = head_dim
        # NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights
        self.scale = qk_scale or head_dim ** -0.5

        self.qk = nn.Linear(dim, hidden_dim * 2, bias=qkv_bias)
        self.v = nn.Linear(dim, dim, bias=qkv_bias)
        self.attn_drop = nn.Dropout(attn_drop, inplace=True)
        self.proj = nn.Linear(dim, dim)
        self.proj_drop = nn.Dropout(proj_drop, inplace=True)

    def forward(self, x):
        B, N, C = x.shape
        qk = self.qk(x).reshape(B, N, 2, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
        q, k = qk[0], qk[1]   # make torchscript happy (cannot use tensor as tuple)
        v = self.v(x).reshape(B, N, self.num_heads, -1).permute(0, 2, 1, 3)

        attn = (q @ k.transpose(-2, -1)) * self.scale
        attn = attn.softmax(dim=-1)
        attn = self.attn_drop(attn)

        x = (attn @ v).transpose(1, 2).reshape(B, N, -1)
        x = self.proj(x)
        x = self.proj_drop(x)
        return x


class Block(nn.Module):
    """ TNT Block
    """
    def __init__(self, outer_dim, inner_dim, outer_num_heads, inner_num_heads, num_words, mlp_ratio=4.,
                 qkv_bias=False, qk_scale=None, drop=0., attn_drop=0., drop_path=0., act_layer=nn.GELU,
                 norm_layer=nn.LayerNorm, se=0):
        super().__init__()
        self.has_inner = inner_dim > 0
        if self.has_inner:
            # Inner
            self.inner_norm1 = norm_layer(inner_dim)
            self.inner_attn = Attention(
                inner_dim, inner_dim, num_heads=inner_num_heads, qkv_bias=qkv_bias,
                qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
            self.inner_norm2 = norm_layer(inner_dim)
            self.inner_mlp = Mlp(in_features=inner_dim, hidden_features=int(inner_dim * mlp_ratio),
                                 out_features=inner_dim, act_layer=act_layer, drop=drop)

            self.proj_norm1 = norm_layer(num_words * inner_dim)
            self.proj = nn.Linear(num_words * inner_dim, outer_dim, bias=False)
            self.proj_norm2 = norm_layer(outer_dim)
        # Outer
        self.outer_norm1 = norm_layer(outer_dim)
        self.outer_attn = Attention(
            outer_dim, outer_dim, num_heads=outer_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.outer_norm2 = norm_layer(outer_dim)
        self.outer_mlp = Mlp(in_features=outer_dim, hidden_features=int(outer_dim * mlp_ratio),
                             out_features=outer_dim, act_layer=act_layer, drop=drop)
        # SE
        self.se = se
        self.se_layer = None
        if self.se > 0:
            self.se_layer = SE(outer_dim, 0.25)

    def forward(self, inner_tokens, outer_tokens):
        if self.has_inner:
            inner_tokens = inner_tokens + self.drop_path(self.inner_attn(self.inner_norm1(inner_tokens))) # B*N, k*k, c
            inner_tokens = inner_tokens + self.drop_path(self.inner_mlp(self.inner_norm2(inner_tokens))) # B*N, k*k, c
            B, N, C = outer_tokens.size()
            outer_tokens[:,1:] = outer_tokens[:,1:] + self.proj_norm2(self.proj(self.proj_norm1(inner_tokens.reshape(B, N-1, -1)))) # B, N, C
        if self.se > 0:
            outer_tokens = outer_tokens + self.drop_path(self.outer_attn(self.outer_norm1(outer_tokens)))
            tmp_ = self.outer_mlp(self.outer_norm2(outer_tokens))
            outer_tokens = outer_tokens + self.drop_path(tmp_ + self.se_layer(tmp_))
        else:
            outer_tokens = outer_tokens + self.drop_path(self.outer_attn(self.outer_norm1(outer_tokens)))
            outer_tokens = outer_tokens + self.drop_path(self.outer_mlp(self.outer_norm2(outer_tokens)))
        return inner_tokens, outer_tokens


class PatchEmbed(nn.Module):
    """ Image to Visual Word Embedding
    """
    def __init__(self, img_size=224, patch_size=16, in_chans=3, outer_dim=768, inner_dim=24, inner_stride=4):
        super().__init__()
        img_size = to_2tuple(img_size)
        patch_size = to_2tuple(patch_size)
        num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0])
        self.img_size = img_size
        self.patch_size = patch_size
        self.num_patches = num_patches
        self.inner_dim = inner_dim
        self.num_words = math.ceil(patch_size[0] / inner_stride) * math.ceil(patch_size[1] / inner_stride)
        
        self.unfold = nn.Unfold(kernel_size=patch_size, stride=patch_size)
        self.proj = nn.Conv2d(in_chans, inner_dim, kernel_size=7, padding=3, stride=inner_stride)

    def forward(self, x):
        B, C, H, W = x.shape
        # FIXME look at relaxing size constraints
        assert H == self.img_size[0] and W == self.img_size[1], \
            f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})."
        # self.unfold = Unfold(kernel_size=(16, 16), dilation=1, padding=0, stride=(16, 16))
        x = self.unfold(x) # B, Ck2, N [1, 768, 196] # 输出行数为卷积核横纵大小相乘，每列为每次卷积核卷过的元素
        x = x.transpose(1, 2).reshape(B * self.num_patches, C, *self.patch_size) # B*N, C, 16, 16 [196, 3, 16, 16]
        x = self.proj(x) # [196, 48, 4, 4]
        x = x.reshape(B * self.num_patches, self.inner_dim, -1).transpose(1, 2) # [196, 16, 48]
        return x


class TNT(nn.Module):
    """ TNT (Transformer in Transformer) for computer vision
    """
    def __init__(self, img_size=224, patch_size=16, in_chans=3, num_classes=1000, outer_dim=768, inner_dim=48,
                 depth=12, outer_num_heads=12, inner_num_heads=4, mlp_ratio=4., qkv_bias=False, qk_scale=None,
                 drop_rate=0., attn_drop_rate=0., drop_path_rate=0., norm_layer=nn.LayerNorm, inner_stride=4, se=0):
        super().__init__()
        self.num_classes = num_classes # 1000
        self.num_features = self.outer_dim = outer_dim  # num_features for consistency with other models

        self.patch_embed = PatchEmbed(
            img_size=img_size, patch_size=patch_size, in_chans=in_chans, outer_dim=outer_dim,
            inner_dim=inner_dim, inner_stride=inner_stride)
        self.num_patches = num_patches = self.patch_embed.num_patches # 196
        num_words = self.patch_embed.num_words # 16
        
        self.proj_norm1 = norm_layer(num_words * inner_dim)     # LayerNorm((768,), eps=1e-05, elementwise_affine=True)
        self.proj = nn.Linear(num_words * inner_dim, outer_dim) # Linear(in_features=768, out_features=768, bias=True)
        self.proj_norm2 = norm_layer(outer_dim)                 # LayerNorm((768,), eps=1e-05, elementwise_affine=True)

        self.cls_token = nn.Parameter(torch.zeros(1, 1, outer_dim)) # [1, 1, 768]
        self.outer_tokens = nn.Parameter(torch.zeros(1, num_patches, outer_dim), requires_grad=False) # [1, 196, 768]
        self.outer_pos = nn.Parameter(torch.zeros(1, num_patches + 1, outer_dim)) # [1, 196, 768]
        self.inner_pos = nn.Parameter(torch.zeros(1, num_words, inner_dim))       # [1, 16, 48]
        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
        vanilla_idxs = []
        blocks = []
        for i in range(depth):
            if i in vanilla_idxs:
                blocks.append(Block(
                    outer_dim=outer_dim, inner_dim=-1, outer_num_heads=outer_num_heads, inner_num_heads=inner_num_heads,
                    num_words=num_words, 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, se=se))
            else:
                blocks.append(Block(
                    outer_dim=outer_dim, inner_dim=inner_dim, outer_num_heads=outer_num_heads, inner_num_heads=inner_num_heads,
                    num_words=num_words, 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, se=se))
        self.blocks = nn.ModuleList(blocks)
        self.norm = norm_layer(outer_dim)

        # NOTE as per official impl, we could have a pre-logits representation dense layer + tanh here
        #self.repr = nn.Linear(outer_dim, representation_size)
        #self.repr_act = nn.Tanh()

        # Classifier head
        self.head = nn.Linear(outer_dim, num_classes) if num_classes > 0 else nn.Identity() # Linear(in_features=768, out_features=1000, bias=True)

        trunc_normal_(self.cls_token, std=.02)
        trunc_normal_(self.outer_pos, std=.02)
        trunc_normal_(self.inner_pos, std=.02)
        self.apply(self._init_weights)
        # import pdb; pdb.set_trace()

    def _init_weights(self, m):
        if isinstance(m, nn.Linear):
            trunc_normal_(m.weight, std=.02)
            if isinstance(m, nn.Linear) and m.bias is not None:
                nn.init.constant_(m.bias, 0)
        elif isinstance(m, nn.LayerNorm):
            nn.init.constant_(m.bias, 0)
            nn.init.constant_(m.weight, 1.0)

    @torch.jit.ignore
    def no_weight_decay(self):
        return {'outer_pos', 'inner_pos', 'cls_token'}

    def get_classifier(self):
        return self.head

    def reset_classifier(self, num_classes, global_pool=''):
        self.num_classes = num_classes
        self.head = nn.Linear(self.outer_dim, num_classes) if num_classes > 0 else nn.Identity()

    def forward_features(self, x):
        # import pdb; pdb.set_trace()
        # x.shape=[1, 3, 224, 224]
        B = x.shape[0] # 1
        inner_tokens = self.patch_embed(x) + self.inner_pos # self.patch_embed(x) = [196, 16, 48], self.inner_pos=[1, 16, 48]
        
        outer_tokens = self.proj_norm2(self.proj(self.proj_norm1(inner_tokens.reshape(B, self.num_patches, -1))))     # [1, 196, 768]
        outer_tokens = torch.cat((self.cls_token.expand(B, -1, -1), outer_tokens), dim=1) # [1, 197, 768]
        
        outer_tokens = outer_tokens + self.outer_pos # [1, 197, 768]
        outer_tokens = self.pos_drop(outer_tokens)   # [1, 197, 768]

        for blk in self.blocks:
            inner_tokens, outer_tokens = blk(inner_tokens, outer_tokens) # inner_tokens.shape=[196, 16, 48]  outer_tokens.shape=[1, 197, 768]

        outer_tokens = self.norm(outer_tokens)
        return outer_tokens[:, 0] # [1, 768]

    def forward(self, x):
        x = self.forward_features(x) # [1, 768]
        x = self.head(x)
        return x


def _conv_filter(state_dict, patch_size=16):
    """ convert patch embedding weight from manual patchify + linear proj to conv"""
    out_dict = {}
    for k, v in state_dict.items():
        if 'patch_embed.proj.weight' in k:
            v = v.reshape((v.shape[0], 3, patch_size, patch_size))
        out_dict[k] = v
    return out_dict


@register_model
def tnt_s_patch16_224(pretrained=False, **kwargs):
    patch_size = 16
    inner_stride = 4
    outer_dim = 384
    inner_dim = 24
    outer_num_heads = 6
    inner_num_heads = 4
    outer_dim = make_divisible(outer_dim, outer_num_heads)
    inner_dim = make_divisible(inner_dim, inner_num_heads)
    model = TNT(img_size=224, patch_size=patch_size, outer_dim=outer_dim, inner_dim=inner_dim, depth=12,
                outer_num_heads=outer_num_heads, inner_num_heads=inner_num_heads, qkv_bias=False,
                inner_stride=inner_stride, **kwargs)
    model.default_cfg = default_cfgs['tnt_s_patch16_224']
    if pretrained:
        load_pretrained(
            model, num_classes=model.num_classes, in_chans=kwargs.get('in_chans', 3), filter_fn=_conv_filter)
    return model


@register_model
def tnt_b_patch16_224(pretrained=False, **kwargs):
    patch_size = 16
    inner_stride = 4
    outer_dim = 640
    inner_dim = 40
    outer_num_heads = 10
    inner_num_heads = 4
    outer_dim = make_divisible(outer_dim, outer_num_heads)
    inner_dim = make_divisible(inner_dim, inner_num_heads)
    model = TNT(img_size=224, patch_size=patch_size, outer_dim=outer_dim, inner_dim=inner_dim, depth=12,
                outer_num_heads=outer_num_heads, inner_num_heads=inner_num_heads, qkv_bias=False,
                inner_stride=inner_stride, **kwargs)
    model.default_cfg = default_cfgs['tnt_b_patch16_224']
    if pretrained:
        load_pretrained(
            model, num_classes=model.num_classes, in_chans=kwargs.get('in_chans', 3), filter_fn=_conv_filter)
    return model

self.blocks

ModuleList(
  (0): Block(
    (inner_norm1): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_attn): Attention(
      (qk): Linear(in_features=48, out_features=96, bias=False)
      (v): Linear(in_features=48, out_features=48, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=48, out_features=48, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (inner_norm2): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_mlp): Mlp(
      (fc1): Linear(in_features=48, out_features=192, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=192, out_features=48, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
    (proj_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (proj): Linear(in_features=768, out_features=768, bias=False)
    (proj_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_attn): Attention(
      (qk): Linear(in_features=768, out_features=1536, bias=False)
      (v): Linear(in_features=768, out_features=768, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=768, out_features=768, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (drop_path): Identity()
    (outer_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_mlp): Mlp(
      (fc1): Linear(in_features=768, out_features=3072, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=3072, out_features=768, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
  )
  (1): Block(
    (inner_norm1): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_attn): Attention(
      (qk): Linear(in_features=48, out_features=96, bias=False)
      (v): Linear(in_features=48, out_features=48, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=48, out_features=48, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (inner_norm2): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_mlp): Mlp(
      (fc1): Linear(in_features=48, out_features=192, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=192, out_features=48, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
    (proj_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (proj): Linear(in_features=768, out_features=768, bias=False)
    (proj_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_attn): Attention(
      (qk): Linear(in_features=768, out_features=1536, bias=False)
      (v): Linear(in_features=768, out_features=768, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=768, out_features=768, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (drop_path): Identity()
    (outer_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_mlp): Mlp(
      (fc1): Linear(in_features=768, out_features=3072, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=3072, out_features=768, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
  )
  (2): Block(
    (inner_norm1): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_attn): Attention(
      (qk): Linear(in_features=48, out_features=96, bias=False)
      (v): Linear(in_features=48, out_features=48, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=48, out_features=48, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (inner_norm2): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_mlp): Mlp(
      (fc1): Linear(in_features=48, out_features=192, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=192, out_features=48, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
    (proj_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (proj): Linear(in_features=768, out_features=768, bias=False)
    (proj_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_attn): Attention(
      (qk): Linear(in_features=768, out_features=1536, bias=False)
      (v): Linear(in_features=768, out_features=768, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=768, out_features=768, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (drop_path): Identity()
    (outer_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_mlp): Mlp(
      (fc1): Linear(in_features=768, out_features=3072, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=3072, out_features=768, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
  )
  (3): Block(
    (inner_norm1): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_attn): Attention(
      (qk): Linear(in_features=48, out_features=96, bias=False)
      (v): Linear(in_features=48, out_features=48, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=48, out_features=48, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (inner_norm2): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_mlp): Mlp(
      (fc1): Linear(in_features=48, out_features=192, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=192, out_features=48, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
    (proj_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (proj): Linear(in_features=768, out_features=768, bias=False)
    (proj_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_attn): Attention(
      (qk): Linear(in_features=768, out_features=1536, bias=False)
      (v): Linear(in_features=768, out_features=768, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=768, out_features=768, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (drop_path): Identity()
    (outer_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_mlp): Mlp(
      (fc1): Linear(in_features=768, out_features=3072, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=3072, out_features=768, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
  )
  (4): Block(
    (inner_norm1): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_attn): Attention(
      (qk): Linear(in_features=48, out_features=96, bias=False)
      (v): Linear(in_features=48, out_features=48, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=48, out_features=48, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (inner_norm2): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_mlp): Mlp(
      (fc1): Linear(in_features=48, out_features=192, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=192, out_features=48, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
    (proj_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (proj): Linear(in_features=768, out_features=768, bias=False)
    (proj_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_attn): Attention(
      (qk): Linear(in_features=768, out_features=1536, bias=False)
      (v): Linear(in_features=768, out_features=768, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=768, out_features=768, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (drop_path): Identity()
    (outer_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_mlp): Mlp(
      (fc1): Linear(in_features=768, out_features=3072, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=3072, out_features=768, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
  )
  (5): Block(
    (inner_norm1): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_attn): Attention(
      (qk): Linear(in_features=48, out_features=96, bias=False)
      (v): Linear(in_features=48, out_features=48, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=48, out_features=48, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (inner_norm2): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_mlp): Mlp(
      (fc1): Linear(in_features=48, out_features=192, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=192, out_features=48, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
    (proj_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (proj): Linear(in_features=768, out_features=768, bias=False)
    (proj_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_attn): Attention(
      (qk): Linear(in_features=768, out_features=1536, bias=False)
      (v): Linear(in_features=768, out_features=768, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=768, out_features=768, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (drop_path): Identity()
    (outer_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_mlp): Mlp(
      (fc1): Linear(in_features=768, out_features=3072, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=3072, out_features=768, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
  )
  (6): Block(
    (inner_norm1): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_attn): Attention(
      (qk): Linear(in_features=48, out_features=96, bias=False)
      (v): Linear(in_features=48, out_features=48, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=48, out_features=48, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (inner_norm2): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_mlp): Mlp(
      (fc1): Linear(in_features=48, out_features=192, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=192, out_features=48, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
    (proj_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (proj): Linear(in_features=768, out_features=768, bias=False)
    (proj_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_attn): Attention(
      (qk): Linear(in_features=768, out_features=1536, bias=False)
      (v): Linear(in_features=768, out_features=768, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=768, out_features=768, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (drop_path): Identity()
    (outer_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_mlp): Mlp(
      (fc1): Linear(in_features=768, out_features=3072, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=3072, out_features=768, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
  )
  (7): Block(
    (inner_norm1): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_attn): Attention(
      (qk): Linear(in_features=48, out_features=96, bias=False)
      (v): Linear(in_features=48, out_features=48, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=48, out_features=48, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (inner_norm2): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_mlp): Mlp(
      (fc1): Linear(in_features=48, out_features=192, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=192, out_features=48, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
    (proj_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (proj): Linear(in_features=768, out_features=768, bias=False)
    (proj_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_attn): Attention(
      (qk): Linear(in_features=768, out_features=1536, bias=False)
      (v): Linear(in_features=768, out_features=768, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=768, out_features=768, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (drop_path): Identity()
    (outer_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_mlp): Mlp(
      (fc1): Linear(in_features=768, out_features=3072, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=3072, out_features=768, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
  )
  (8): Block(
    (inner_norm1): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_attn): Attention(
      (qk): Linear(in_features=48, out_features=96, bias=False)
      (v): Linear(in_features=48, out_features=48, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=48, out_features=48, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (inner_norm2): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_mlp): Mlp(
      (fc1): Linear(in_features=48, out_features=192, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=192, out_features=48, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
    (proj_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (proj): Linear(in_features=768, out_features=768, bias=False)
    (proj_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_attn): Attention(
      (qk): Linear(in_features=768, out_features=1536, bias=False)
      (v): Linear(in_features=768, out_features=768, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=768, out_features=768, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (drop_path): Identity()
    (outer_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_mlp): Mlp(
      (fc1): Linear(in_features=768, out_features=3072, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=3072, out_features=768, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
  )
  (9): Block(
    (inner_norm1): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_attn): Attention(
      (qk): Linear(in_features=48, out_features=96, bias=False)
      (v): Linear(in_features=48, out_features=48, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=48, out_features=48, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (inner_norm2): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_mlp): Mlp(
      (fc1): Linear(in_features=48, out_features=192, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=192, out_features=48, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
    (proj_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (proj): Linear(in_features=768, out_features=768, bias=False)
    (proj_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_attn): Attention(
      (qk): Linear(in_features=768, out_features=1536, bias=False)
      (v): Linear(in_features=768, out_features=768, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=768, out_features=768, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (drop_path): Identity()
    (outer_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_mlp): Mlp(
      (fc1): Linear(in_features=768, out_features=3072, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=3072, out_features=768, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
  )
  (10): Block(
    (inner_norm1): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_attn): Attention(
      (qk): Linear(in_features=48, out_features=96, bias=False)
      (v): Linear(in_features=48, out_features=48, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=48, out_features=48, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (inner_norm2): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_mlp): Mlp(
      (fc1): Linear(in_features=48, out_features=192, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=192, out_features=48, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
    (proj_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (proj): Linear(in_features=768, out_features=768, bias=False)
    (proj_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_attn): Attention(
      (qk): Linear(in_features=768, out_features=1536, bias=False)
      (v): Linear(in_features=768, out_features=768, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=768, out_features=768, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (drop_path): Identity()
    (outer_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_mlp): Mlp(
      (fc1): Linear(in_features=768, out_features=3072, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=3072, out_features=768, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
  )
  (11): Block(
    (inner_norm1): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_attn): Attention(
      (qk): Linear(in_features=48, out_features=96, bias=False)
      (v): Linear(in_features=48, out_features=48, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=48, out_features=48, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (inner_norm2): LayerNorm((48,), eps=1e-05, elementwise_affine=True)
    (inner_mlp): Mlp(
      (fc1): Linear(in_features=48, out_features=192, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=192, out_features=48, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
    (proj_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (proj): Linear(in_features=768, out_features=768, bias=False)
    (proj_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_attn): Attention(
      (qk): Linear(in_features=768, out_features=1536, bias=False)
      (v): Linear(in_features=768, out_features=768, bias=False)
      (attn_drop): Dropout(p=0.0, inplace=True)
      (proj): Linear(in_features=768, out_features=768, bias=True)
      (proj_drop): Dropout(p=0.0, inplace=True)
    )
    (drop_path): Identity()
    (outer_norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (outer_mlp): Mlp(
      (fc1): Linear(in_features=768, out_features=3072, bias=True)
      (act): GELU()
      (fc2): Linear(in_features=3072, out_features=768, bias=True)
      (drop): Dropout(p=0.0, inplace=False)
    )
  )
)

你可能感兴趣的:(Transformer,transformer,计算机视觉,深度学习)

深度学习过程是什么小松要进步李哥深度学习深度学习
问：深度学习是：一组原始数据，经过线性变换、非线性变换、偏差加和等操作后得到一组预测数据，再根据损失函数计算预测数据和原始数据的差值，用差值数据对权重和偏差求偏导，这里的偏导数的值也就是使得损失减小的最佳方向，然后根据偏导数的方向和步长更新权重和偏差，对吗答：您的描述大致正确，但有一些细节需要澄清和修正，以更准确地反映深度学习中模型训练的过程。以下是详细的解释：1.原始数据处理：一组原始数据首先通
TensorBoard可视化工具支持哪些类型的图表？ alankuo 人工智能
TensorBoard支持多种类型的图表，以下是详细介绍：标量图（Scalars）定义与用途：用于展示单个数值随时间（通常是训练步骤或迭代次数）的变化情况。在深度学习模型训练中，最常见的是损失函数值和评估指标（如准确率、精确率、召回率等）的变化曲线。示例：例如，在训练一个图像分类模型时，记录训练集和测试集上的损失函数值。通过标量图，可以直观地看到随着训练轮次（epochs）的增加，损失函数值是如何
学习python你必须弄懂的 Python、Pycharm、Anaconda 三者之间的关系经纬数智 python python pycharm 开发语言 conda
Python作为深度学习和人工智能学习的热门语言，学习一门语言，除了学会其简单的语法之外还需要对其进行运行和实现，才能实现和发挥其功能和作用。下面来介绍运行Python代码常用到的工具总结。一.Python、Pycharm、Anaconda关系介绍1.PythonPython是一种跨平台的计算机程序语言。是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。最初被设计用于编写自动化脚本(
CUDA编程（一）：GPU计算与CUDA编程简介 AI Player CUDA 人工智能 CUDA NVIDIA
CUDA编程（一）：GPU计算与CUDA编程简介GPU计算GPU硬件资源GPU软件资源GPU存储资源CUDA编程GPU计算NVIDIA公司发布的CUDA是建立在GPU上的一个通用并行计算平台和编程模型，CUDA编程可以利用GPU的并行计算引擎来更加高效地解决比较复杂的计算难题。GPU的并行计算最成功的一个应用就是深度学习领域。GPU通常不作为一个独立运行的计算平台，而需要与CPU协同工作，它可以看
AI 大模型创业：如何利用商业优势？ AI天才研究院大数据AI人工智能 ChatGPT java python javascript kotlin golang 架构人工智能大厂程序员硅基计算碳基计算认知计算生物计算深度学习神经网络大数据 AIGC AGI LLM 系统架构设计软件哲学 Agent 程序员实现财富自由
第1章：AI大模型概述1.1AI大模型的概念与演进AI大模型（Large-scaleArtificialIntelligenceModels）是指通过大规模数据训练得到的复杂神经网络模型。这些模型通常具有数十亿甚至千亿个参数，能够实现从自然语言处理到计算机视觉、语音识别等广泛领域的任务。AI大模型的概念起源于20世纪80年代，当时研究人员提出了深度学习（DeepLearning）这一概念。深度学习
Open WebUI应用实践孙将帼
open-webui/open-webui:User-friendlyWebUIforLLMs(FormerlyOllamaWebUI)(github.com)Tutorial|OpenWebUIOpenWebUITip:OpenWebUI、Ollama、Helm、ChromaDB、RAG、Pipelines、sentence-transformers库、1、OpenWebUI是一个可扩展的、自托
语言模型与向量模型：深入解析与实例剖析 ♢.＊语言模型人工智能自然语言处理
亲爱的小伙伴们，在求知的漫漫旅途中，若你对深度学习的奥秘、Java与Python的奇妙世界，亦或是读研论文的撰写攻略有所探寻，那不妨给我一个小小的关注吧。我会精心筹备，在未来的日子里不定期地为大家呈上这些领域的知识宝藏与实用经验分享。每一个点赞，都如同春日里的一缕阳光，给予我满满的动力与温暖，让我们在学习成长的道路上相伴而行，共同进步✨。期待你的关注与点赞哟！在自然语言处理领域，语言模型和向量模型
Python 调用常见大模型 API 全解析 ♢.＊ python 开发语言语言模型 nlp
亲爱的小伙伴们，在求知的漫漫旅途中，若你对深度学习的奥秘、JAVA、PYTHON与SAP的奇妙世界，亦或是读研论文的撰写攻略有所探寻，那不妨给我一个小小的关注吧。我会精心筹备，在未来的日子里不定期地为大家呈上这些领域的知识宝藏与实用经验分享。每一个点赞，都如同春日里的一缕阳光，给予我满满的动力与温暖，让我们在学习成长的道路上相伴而行，共同进步✨。期待你的关注与点赞哟！调用通义千问接口获取APIKe
AI编译器之——为什么大模型需要Relax？ FF-Studio 人工智能深度学习自然语言处理机器学习语言模型
放在最前：Relax的关键创新深度学习模型（比如ChatGPT这种大模型）在运行时经常遇到“输入尺寸不固定”的情况。比如你问它一个问题，这次输入是10个字，下次可能是100个字。传统编译器处理这种“变来变去”的尺寸很笨——要么只能按固定尺寸优化（导致变尺寸时性能暴跌），要么每次都要重新编译（慢到没法用）。Relax的创新：符号形状：让编译器学会“代数”Relax允许编译器用“符号变量”（比如n）表
Apache TVM：开源深度学习编译器栈的领跑者计攀建Eliza
ApacheTVM：开源深度学习编译器栈的领跑者tvmOpendeeplearningcompilerstackforcpu,gpuandspecializedaccelerators项目地址:https://gitcode.com/gh_mirrors/tv/tvm项目介绍ApacheTVM是一个专为深度学习系统设计的编译器栈。它旨在弥合生产力导向的深度学习框架与性能和效率导向的硬件后端之间的差
Transformer代码怎么写？原理一听就懂，代码一写就废！分享我从理解原理到实际编写代码的转换秘籍夜信431 transformer 深度学习人工智能
这个困惑非常典型，这正是从"理解者"到"创造者"的关键跃迁阶段。让我们用建造房子的比喻，结合具体代码实例，拆解这个转化过程：示例代码(已加注释)：importosimportplatformimporttimeimportmathimportwarningsimporttorchimporttorch.distributedasdistfromtorchimportoptimfromtorch.n
Deepseek 对种猪市场会带来哪些影响？百态老人笔记大数据人工智能
DeepSeek对种猪市场的影响可以从以下几个方面进行分析：1.提高生产效率与降低成本根据，DeepSeek已经被用于养猪场中分析饲料配比，从而将猪的育肥周期从6个月缩短至5个月，并降低了15%的成本。这表明DeepSeek在优化养殖流程和提高生产效率方面具有显著作用，能够帮助养猪场降低运营成本，提升经济效益。2.推动智能化养殖技术的应用和提到，深度学习技术（如YOLOv5模型）已经被应用于生猪的
CVPR‘24开源 | ADA-Track：端到端3D多目标跟踪最新SOTA！计算机视觉工坊 3D视觉从入门到精通 3d 目标跟踪人工智能
编辑：计算机视觉工坊添加小助理：dddvision，备注：方向+学校/公司+昵称，拉你入群。文末附行业细分群扫描下方二维码，加入3D视觉知识星球，星球内凝聚了众多3D视觉实战问题，以及各个模块的学习资料：近20门视频课程（星球成员免费学习）、最新顶会论文、3DGS系列、计算机视觉书籍、优质3D视觉算法源码等。想要入门3D视觉、做项目、搞科研，欢迎扫码加入！
获取PPT中的MSO格式图片报错 ♢.＊ ppt python
亲爱的小伙伴们，在求知的漫漫旅途中，若你对深度学习的奥秘、Java与Python的奇妙世界，亦或是读研论文的撰写攻略有所探寻，那不妨给我一个小小的关注吧。我会精心筹备，在未来的日子里不定期地为大家呈上这些领域的知识宝藏与实用经验分享。每一个点赞，都如同春日里的一缕阳光，给予我满满的动力与温暖，让我们在学习成长的道路上相伴而行，共同进步✨。期待你的关注与点赞哟！image.ext的报错ValueEr
知识图谱技术剖析 ♢.＊人工智能知识图谱大数据
亲爱的小伙伴们，在求知的漫漫旅途中，若你对深度学习的奥秘、Java与Python的奇妙世界，亦或是读研论文的撰写攻略有所探寻，那不妨给我一个小小的关注吧。我会精心筹备，在未来的日子里不定期地为大家呈上这些领域的知识宝藏与实用经验分享。每一个点赞，都如同春日里的一缕阳光，给予我满满的动力与温暖，让我们在学习成长的道路上相伴而行，共同进步✨。期待你的关注与点赞哟！一、引言在当今数字化信息爆炸的时代，如
python神经网络框架有哪些,python调用神经网络模型小明技术分享 python 神经网络深度学习
人工智能Python深度学习库有哪些由于Python的易用性和可扩展性，众多深度学习框架提供了Python接口，其中较为流行的深度学习库如下：第一：CaffeCaffe是一个以表达式、速度和模块化为核心的深度学习框架，具备清晰、可读性高和快速的特性，在视频、图像处理方面应用较多。Caffe中的网络结构与优化都以配置文件形式定义，容易上手，无须通过代码构建网络;网络训练速度快，能够训练大型数据集与S
OpenCV中的图像处理函数详解 Luzem0319 opencv 图像处理人工智能
在OpenCV中，图像处理函数是实现图像处理和计算机视觉任务的基础。下面将详细介绍六个重要的图像处理函数：二值化函数、自适应二值化函数、腐蚀函数、膨胀函数、仿射变换函数和透视变换函数。一、二值化函数功能二值化函数（cv2.threshold()）用于将灰度图像转换为二值图像。二值图像中，每个像素只有两种可能的值（通常是0和255），分别代表黑色和白色。参数src：输入图像，应为灰度图像。thres
OpenCV中的边缘检测和轮廓处理 Luzem0319 opencv 人工智能计算机视觉
在图像处理和计算机视觉任务中，边缘检测和轮廓处理是非常重要的步骤。OpenCV库提供了多种函数来实现这些功能，包括Sobel算子、Laplacian算子、Canny算子、findContours函数、drawContours函数以及透视变换函数等。本文将详细介绍这些函数的功能、参数、返回值和应用。1.Sobel算子函数功能：Sobel算子用于计算图像灰度的近似梯度，梯度越大越有可能是边缘。参数：s
Python实现复原毫米波雷达呼吸波形的示例 go5463158465 python 算法机器学习 python 开发语言
以下是一个使用Python实现复原毫米波雷达呼吸波形的示例，该示例将涉及模型算法在重建损失和KL（Kullback-Leibler）损失之间的平衡问题。我们将使用深度学习中的变分自编码器（VAE）作为模型来进行呼吸波形的复原，因为VAE可以很好地处理重建和潜在空间分布的问题。步骤概述数据准备：生成或加载毫米波雷达的呼吸波形数据。定义VAE模型：包括编码器和解码器。定义损失函数：结合重建损失和KL损
对话系统(Chatbots) 原理与代码实例讲解 AI天才研究院 AI大模型企业级应用开发实战大数据AI人工智能计算科学神经计算深度学习神经网络大数据人工智能大型语言模型 AI AGI LLM Java Python 架构设计 Agent RPA
1.背景介绍1.1对话系统的发展历程对话系统，又称聊天机器人(Chatbots)，是模拟人类对话的计算机程序。从早期的基于规则的系统到如今基于深度学习的智能体，对话系统经历了漫长的发展历程。第一阶段：基于规则的系统(1960s-1990s)早期的对话系统主要基于预先定义的规则和模板。例如，ELIZA(1966)是一个模拟心理治疗师的程序，通过模式匹配和关键词识别来生成回复。这些系统只能处理有限的对
如何使用深度学习中的 Transformer 算法进行视频目标检测 go5463158465 python 算法深度学习 python 开发语言
以下将介绍如何使用深度学习中的Transformer算法进行视频目标检测，并给出一个复现相关论文思路及示例代码。这里以DETR（End-to-EndObjectDetectionwithTransformers）为基础进行说明，它是将Transformer引入目标检测领域的经典论文。步骤概述环境准备：安装必要的库，如PyTorch、torchvision等。数据准备：使用公开的视频目标检测数据集，
大模型问答机器人的智能化程度 AI大模型应用之禅 AI大模型与大数据 java python javascript kotlin golang 架构人工智能
大模型、问答机器人、智能化程度、自然语言处理、深度学习、Transformer模型、知识图谱、推理能力、对话系统1.背景介绍近年来，人工智能技术取得了飞速发展，特别是深度学习的兴起，为自然语言处理（NLP）领域带来了革命性的变革。其中，大模型问答机器人作为一种新型的智能交互系统，凭借其强大的语言理解和生成能力，在客服、教育、娱乐等领域展现出广阔的应用前景。问答机器人是指能够理解用户自然语言问题并给
大语言模型原理与工程实践：残差连接与层归一化 AI大模型应用之禅 AI大模型与大数据计算科学神经计算深度学习神经网络大数据人工智能大型语言模型 AI AGI LLM Java Python 架构设计 Agent RPA
1.背景介绍随着自然语言处理（NLP）的发展，深度学习在过去几年中取得了令人瞩目的成果。其中，循环神经网络（RNN）和卷积神经网络（CNN）在图像和文本分类、语义角色标注、机器翻译等领域表现出色。然而，这些网络在训练过程中经常遭遇梯度消失和梯度爆炸的问题。为了解决这些问题，我们引入了残差连接（ResidualConnections）和层归一化（BatchNormalization）来改善模型性能。
Transformer架构原理详解：残差连接和层归一化（Residual Connection an AI天才研究院 AI大模型企业级应用开发实战 Python实战大数据AI人工智能 java python javascript kotlin golang 架构人工智能大厂程序员硅基计算碳基计算认知计算生物计算深度学习神经网络大数据 AIGC AGI LLM 系统架构设计软件哲学 Agent 程序员实现财富自由
《Transformer架构原理详解：残差连接和层归一化（ResidualConnectionandLayerNormalization）》文章关键词Transformer残差连接层归一化自注意力机制序列模型编码器与解码器摘要本文将深入解析Transformer架构的核心原理，特别是残差连接和层归一化技术。通过详细阐述这些关键组件的作用、数学模型和具体实现，读者将能够理解Transformer在处
模型架构选择：从传统NLP到Transformer AI天才研究院 AI大模型应用入门实战与进阶大数据AI人工智能计算大数据人工智能语言模型 AI 大模型 LLM Java Python 架构设计 Agent RPA
模型架构选择：从传统NLP到Transformer关键词：自然语言处理(NLP),模型架构,传统NLP,Transformer,RNN,CNN,预训练模型文章目录模型架构选择：从传统NLP到Transformer1.背景介绍1.1问题的由来1.2研究现状1.3研究意义1.4本文结构2.核心概念与联系3.核心算法原理&具体操作步骤3.1算法原理概述3.1.1传统NLP模型3.1.2RNN模型3.1.
Transformer架构的GPU并行和之前的NLP算法并行有什么不同？ AI大模型学习不迷路 transformer 自然语言处理大模型深度学习 NLP LLM 大语言模型
1.什么是GPU并行计算？GPU并行计算是一种利用图形处理单元（GPU）进行大规模并行数据处理的技术。与传统的中央处理单元（CPU）相比，GPU拥有更多的核心，能够同时处理数千个线程，这使得GPU在处理高度并行的任务时表现出色。在深度学习中，GPU并行计算被广泛应用于训练神经网络，加速模型训练过程。在2017年之前，自然语言处理（NLP）领域的研究者们通常会从头开始训练模型，那时能够利用GPU进行
计算机视觉：解锁未来智能的钥匙及其代码实践我的运维人生计算机视觉人工智能运维开发技术共享
计算机视觉：解锁未来智能的钥匙及其代码实践在当今这个数据爆炸的时代，计算机视觉作为人工智能的一个重要分支，正以前所未有的速度推动着科技的边界。它不仅让机器“看懂”世界，更在自动驾驶、医疗影像分析、智能制造、安防监控等众多领域展现出巨大的应用潜力。本文将深入探讨计算机视觉的核心技术、最新进展，并通过一个具体的代码案例，展示如何在实践中应用这些技术，旨在为读者提供一个理论与实践相结合的全面视角。一、计
《向量数据库指南》——MoE应用：解锁深度学习新境界的钥匙大禹智库《实战AI智能体》《向量数据库指南》深度学习人工智能向量数据库大禹智库低代码 MoE模型
在深度学习的广阔天地里，混合专家（MoE）模型如同一把锐利的钥匙，正逐步解锁着各种复杂应用场景的新境界。作为大禹智库的向量数据库高级研究员，同时也是《向量数据库指南》的作者，我深感MoE模型在推动AI技术向前发展中所扮演的重要角色。今天，我将带大家深入探讨MoE模型在自然语言处理、计算机视觉以及多模态学习等领域的应用，并巧妙引导大家通过《向量数据库指南》获取更多干货和深度实战经验。一、自然语言处理
LLM based Single Agent System AGI大模型与大数据研究院大数据AI人工智能计算科学神经计算深度学习神经网络大数据人工智能大型语言模型 AI AGI LLM Java Python 架构设计 Agent RPA
LLM-BasedSingleAgentSystem:ANewEraofIntelligentAutomation关键词：大语言模型，单智能体系统，强化学习，自然语言处理，智能自动化1.背景介绍近年来，随着深度学习技术的快速发展，大语言模型(LLM)在自然语言处理(NLP)领域取得了突破性进展。LLM凭借其强大的语言理解和生成能力，正在改变着人们与信息交互的方式。同时，人工智能领域的另一个重要研究
YOLO 目标检测编程详解不知名靓仔 YOLO 目标检测人工智能
引言目标检测是计算机视觉中的一个重要任务，它旨在识别图像中的对象并定位这些对象的位置。YOLO（YouOnlyLookOnce）是一种流行的目标检测算法，因其速度快且准确度高而广受好评。本文将深入探讨YOLO的原理及其实现方法，并提供一个使用Python和PyTorch的示例代码。项目源码见最下方1.YOLO算法简介YOLO算法的核心思想是将目标检测视为回归问题，而不是传统的分类加定位的两阶段方法
PHP，安卓，UI，java，linux视频教程合集 cocos2d-x小菜 java UI linux PHP android
╔-----------------------------------╗┆
zookeeper admin 笔记 braveCS zookeeper
Required Software 1) JDK>=1.6 2)推荐使用ensemble的ZooKeeper(至少3台)，并run on separate machines 3)在Yahoo!，zk配置在特定的RHEL boxes里，2个cpu，2G内存，80G硬盘数据和日志目录 1)数据目录里的文件是zk节点的持久化备份，包括快照和事务日
Spring配置多个连接池 easterfly spring
项目中需要同时连接多个数据库的时候，如何才能在需要用到哪个数据库就连接哪个数据库呢？ Spring中有关于dataSource的配置： <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" &nb
Mysql 171815164 mysql
例如，你想myuser使用mypassword从任何主机连接到mysql服务器的话。 GRANT ALL PRIVILEGES ON *.* TO 'myuser'@'%'IDENTIFIED BY 'mypassword' WI TH GRANT OPTION; 如果你想允许用户myuser从ip为192.168.1.6的主机连接到mysql服务器，并使用mypassword作
CommonDAO（公共/基础DAO） g21121 DAO
好久没有更新博客了，最近一段时间工作比较忙，所以请见谅，无论你是爱看呢还是爱看呢还是爱看呢，总之或许对你有些帮助。 DAO(Data Access Object)是一个数据访问（顾名思义就是与数据库打交道）接口，DAO一般在业
直言有讳永夜-极光感悟随笔
1.转载地址:http://blog.csdn.net/jasonblog/article/details/10813313 精华: “直言有讳”是阿里巴巴提倡的一种观念，而我在此之前并没有很深刻的认识。为什么呢？就好比是读书时候做阅读理解，我喜欢我自己的解读，并不喜欢老师给的意思。在这里也是。我自己坚持的原则是互相尊重，我觉得阿里巴巴很多价值观其实是基本的做人
安装CentOS 7 和Win 7后，Win7 引导丢失随便小屋 centos
一般安装双系统的顺序是先装Win7，然后在安装CentOS，这样CentOS可以引导WIN 7启动。但安装CentOS7后，却找不到Win7 的引导，稍微修改一点东西即可。一、首先具有root 的权限。即进入Terminal后输入命令su，然后输入密码即可二、利用vim编辑器打开/boot/grub2/grub.cfg文件进行修改 v
Oracle备份与恢复案例 aijuans oracle
Oracle备份与恢复案例一. 理解什么是数据库恢复当我们使用一个数据库时，总希望数据库的内容是可靠的、正确的，但由于计算机系统的故障（硬件故障、软件故障、网络故障、进程故障和系统故障）影响数据库系统的操作，影响数据库中数据的正确性，甚至破坏数据库，使数据库中全部或部分数据丢失。因此当发生上述故障后，希望能重构这个完整的数据库，该处理称为数据库恢复。恢复过程大致可以分为复原(Restore)与
JavaEE开源快速开发平台G4Studio v5.0发布無為子
我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V5.0版本已经正式发布。访问G4Studio网站 http://www.g4it.org 2013-04-06 发布G4Studio_V5.0版本功能新增 (1). 新增了调用Oracle存储过程返回游标，并将游标映射为Java List集合对象的标
Oracle显示根据高考分数模拟录取百合不是茶 PL/SQL编程 oracle例子模拟高考录取学习交流
题目要求: 1,创建student表和result表 2,pl/sql对学生的成绩数据进行处理 3,处理的逻辑是根据每门专业课的最低分线和总分的最低分数线自动的将录取和落选 1,创建student表,和result表学生信息表; create table student( student_id number primary key,--学生id
优秀的领导与差劲的领导 bijian1013 领导管理团队
责任优秀的领导：优秀的领导总是对他所负责的项目担负起责任。如果项目不幸失败了，那么他知道该受责备的人是他自己，并且敢于承认错误。差劲的领导：差劲的领导觉得这不是他的问题，因此他会想方设法证明是他的团队不行，或是将责任归咎于团队中他不喜欢的那几个成员身上。努力工作优秀的领导：团队领导应该是团队成员的榜样。至少，他应该与团队中的其他成员一样努力工作。这仅仅因为他
js函数在浏览器下的兼容 Bill_chen jquery 浏览器 IE DWR ext
做前端开发的工程师，少不了要用FF进行测试，纯js函数在不同浏览器下，名称也可能不同。对于IE6和FF，取得下一结点的函数就不尽相同： IE6：node.nextSibling,对于FF是不能识别的； FF：node.nextElementSibling,对于IE是不能识别的；兼容解决方式：var Div = node.nextSibl
【JVM四】老年代垃圾回收：吞吐量垃圾收集器(Throughput GC) bit1129 垃圾回收
吞吐量与用户线程暂停时间衡量垃圾回收算法优劣的指标有两个：吞吐量越高，则算法越好暂停时间越短，则算法越好首先说明吞吐量和暂停时间的含义。垃圾回收时，JVM会启动几个特定的GC线程来完成垃圾回收的任务，这些GC线程与应用的用户线程产生竞争关系，共同竞争处理器资源以及CPU的执行时间。GC线程不会对用户带来的任何价值，因此，好的GC应该占
J2EE监听器和过滤器基础白糖_ J2EE
Servlet程序由Servlet，Filter和Listener组成，其中监听器用来监听Servlet容器上下文。监听器通常分三类：基于Servlet上下文的ServletContex监听，基于会话的HttpSession监听和基于请求的ServletRequest监听。 ServletContex监听器 ServletContex又叫application
博弈AngularJS讲义(16) - 提供者 boyitech js AngularJS api Angular Provider
Angular框架提供了强大的依赖注入机制，这一切都是有注入器(injector)完成. 注入器会自动实例化服务组件和符合Angular API规则的特殊对象，例如控制器，指令，过滤器动画等。那注入器怎么知道如何去创建这些特殊的对象呢？ Angular提供了5种方式让注入器创建对象，其中最基础的方式就是提供者(provider), 其余四种方式(Value, Fac
java-写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。 bylijinnan java
public class CommonSubSequence { /** * 题目：写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。 * 写一个版本算法复杂度O(N^2)和一个O(N) 。 * * O(N^2)：对于a中的每个字符，遍历b中的每个字符，如果相同，则拷贝到新字符串中。 * O(
sqlserver 2000 无法验证产品密钥 Chen.H sql windows SQL Server Microsoft
在 Service Pack 4 (SP 4), 是运行 Microsoft Windows Server 2003、 Microsoft Windows Storage Server 2003 或 Microsoft Windows 2000 服务器上您尝试安装 Microsoft SQL Server 2000 通过卷许可协议 (VLA) 媒体。这样做, 收到以下错误信息CD KEY的 SQ
[新概念武器]气象战争 comsci
气象战争的发动者必须是拥有发射深空航天器能力的国家或者组织.... 原因如下: 地球上的气候变化和大气层中的云层涡旋场有密切的关系,而维持一个在大气层某个层次
oracle 中 rollup、cube、grouping 使用详解 daizj oracle grouping rollup cube
oracle 中 rollup、cube、grouping 使用详解 -- 使用oracle 样例表演示转自namesliu -- 使用oracle 的样列库，演示 rollup, cube, grouping 的用法与使用场景 --- ROLLUP ，为了理解分组的成员数量，我增加了分组的计数 COUNT(SAL)
技术资料汇总分享 Dead_knight 技术资料汇总分享
本人汇总的技术资料，分享出来，希望对大家有用。 http://pan.baidu.com/s/1jGr56uE 资料主要包含： Workflow->工作流相关理论、框架(OSWorkflow、JBPM、Activiti、fireflow...) Security->java安全相关资料(SSL、SSO、SpringSecurity、Shiro、JAAS...) Ser
初一下学期难记忆单词背诵第一课 dcj3sjt126com english word
could 能够 minute 分钟 Tuesday 星期二 February 二月 eighteenth 第十八 listen 听 careful 小心的，仔细的 short 短的 heavy 重的 empty 空的 certainly 当然 carry 携带；搬运 tape 磁带 basket 蓝子 bottle 瓶 juice 汁，果汁 head 头；头部
截取视图的图片, 然后分享出去 dcj3sjt126com OS Objective-C
OS 7 has a new method that allows you to draw a view hierarchy into the current graphics context. This can be used to get an UIImage very fast. I implemented a category method on UIView to get the vi
MySql重置密码 fanxiaolong MySql重置密码
方法一: 在my.ini的[mysqld]字段加入： skip-grant-tables 重启mysql服务，这时的mysql不需要密码即可登录数据库然后进入mysql mysql>use mysql; mysql>更新 user set password=password('新密码') WHERE User='root'; mysq
Ehcache（03）——Ehcache中储存缓存的方式 234390216 ehcache MemoryStore DiskStore 存储驱除策略
Ehcache中储存缓存的方式目录 1 堆内存（MemoryStore） 1.1 指定可用内存 1.2 驱除策略 1.3 元素过期 2 &nbs
spring mvc中的@propertysource jackyrong spring mvc
在spring mvc中，在配置文件中的东西，可以在java代码中通过注解进行读取了： @PropertySource 在spring 3.1中开始引入比如有配置文件 config.properties mongodb.url=1.2.3.4 mongodb.db=hello 则代码中 @PropertySource(&
重学单例模式 lanqiu17 单例 Singleton 模式
最近在重新学习设计模式，感觉对模式理解更加深刻。觉得有必要记下来。第一个学的就是单例模式，单例模式估计是最好理解的模式了。它的作用就是防止外部创建实例，保证只有一个实例。单例模式的常用实现方式有两种，就人们熟知的饱汉式与饥汉式，具体就不多说了。这里说下其他的实现方式静态内部类方式: package test.pattern.singleton.statics; publ
.NET开源核心运行时，且行且珍惜 netcome java .net 开源
背景 2014年11月12日，ASP.NET之父、微软云计算与企业级产品工程部执行副总裁Scott Guthrie，在Connect全球开发者在线会议上宣布，微软将开源全部.NET核心运行时，并将.NET 扩展为可在 Linux 和 Mac OS 平台上运行。.NET核心运行时将基于MIT开源许可协议发布，其中将包括执行.NET代码所需的一切项目——CLR、JIT编译器、垃圾收集器（GC）和核心
使用oscahe缓存技术减少与数据库的频繁交互 Everyday都不同 Web 高并发 oscahe缓存
此前一直不知道缓存的具体实现，只知道是把数据存储在内存中，以便下次直接从内存中读取。对于缓存的使用也没有概念，觉得缓存技术是一个比较”神秘陌生“的领域。但最近要用到缓存技术，发现还是很有必要一探究竟的。缓存技术使用背景：一般来说，对于web项目，如果我们要什么数据直接jdbc查库好了，但是在遇到高并发的情形下，不可能每一次都是去查数据库，因为这样在高并发的情形下显得不太合理——
Spring+Mybatis 手动控制事务 toknowme mybatis
@Override public boolean testDelete(String jobCode) throws Exception { boolean flag = false; &nbs
菜鸟级的android程序员面试时候需要掌握的知识点 xp9802 android
熟悉Android开发架构和API调用掌握APP适应不同型号手机屏幕开发技巧熟悉Android下的数据存储熟练Android Debug Bridge Tool 熟练Eclipse/ADT及相关工具熟悉Android框架原理及Activity生命周期熟练进行Android UI布局熟练使用SQLite数据库；熟悉Android下网络通信机制，S