精华内容
下载资源
问答
  • matlab中绿色的代码的英文 介绍 本文档主要列出了用于在卫星图像上执行深度学习(DL)的资源。 在较小程度上,还讨论了机器学习(例如随机森林,随机梯度下降等机器学习),以及传统的图像处理技术。...
  • deep learning 随手笔记

    2016-12-23 00:40:42
    损失函数目前不知道什么意思 GPU加速方案指的是用GPU Nvdia一类的工具来优化编程 上一篇博客提到需要3.0以上的GPU CUDA Capability才能跑CUDNN,这个目前存疑,是需要升级硬件还是需要升级软件呢?

    deep learning出论文的三个方向:模型优化,损失函数,GPU加速方案。

    损失函数目前不知道什么意思

    GPU加速方案指的是用GPU Nvdia一类的工具来优化编程

    上一篇博客提到需要3.0以上的GPU CUDA Capability才能跑CUDNN,这个目前存疑,是需要升级硬件还是需要升级软件呢?

    展开全文
  • matlab中绿色的代码的英文 介绍 本文档主要列出了用于在卫星图像上执行深度学习(DL)的资源。 在较小程度上,还讨论了机器学习(例如随机森林,随机梯度下降等机器学习),以及传统的图像处理技术。...
  • 1.什么是深度学习 三张图理解深度学习工作原理 神经网络中每层对输入数据所做的具体操作保存在该层的权重(weight)中,其本质是一串数字。用术语来说,每层实现的变换由其权重来参数化(parameterize,见图 1-7)...
  • Xception 是Google 的the state of art CNN based model。结合了inception和Resnet 的优点并加以改进。 1.Inception Inception的 提出的因为发现经典CNN的卷积模块同时在做...什么意思呢?可以先了解下背景知识:

    Xception 是Google 的the state of art CNN based model。结合了inception和Resnet 的优点并加以改进。


    1.Inception

    Inception的提出的基本思想是将cross-channel correlations和spatial correlations分开进行。什么意思呢?可以先了解下背景知识:知乎:在 Caffe 中如何计算卷积?答案见贾神和beanfrog的回答。

                        

    CNN中的卷积原理是先卷积第1个feature map,得到一个temp map 1,这是spatial correlations,也就是在一个2D的卷积。再卷积第2...N个feature map,得到temp map 2...N。再把所有temp map相加,得到一个输出的feature map,这是cross-channel correlations,结合spatial correlations就是3D的卷积了。Inception module认为同时计算2种correlation不够效率和很复杂,所以把两种correlation的计算分开。具体做法是先进行1*1的3D 卷积,在此基础上进行3*3 的3D卷积。1*1的卷积并没有提取二维空间的信息,所以map的是cross-channel correlations。而在这之后进行3*3的卷积map的是spatial correlations。所以2种correlations的提取一定程度上是分开进行了。


    除此之外,Inception module还使模型的参数大大降低。比如,对于一组32*32*256的feature map,用3*3的卷积核卷积,希望输出是96 channel,则需要的权重数是256*3*3*96。假如先用1*1的卷积核将channel数降维至128,在进行3*3的卷积,则需要256*1*1*128+128*3*3*96,少了三分之一的参数。


    另外,《Going deeper》那篇文章是从计算资源和网络的稀疏性来解释Inception的优点。将网络做大是CNN发展的一个趋势,但有限的计算资源跟不上模型的增大。其中计算资源没能有效利用的一个原因是存在稀疏的数据。于是文章在思考一件事情,如何将网络中稀疏的结构用稠密的成分代替。原文:

    The main idea of the Inception architecture is based on finding out how an optimal local sparsestructure in a convolutional vision network can be approximated and covered by readily availabledense components 。另外,还有一句,

    The vast literature on sparse matrixcomputations (e.g. [3]) suggests that clustering sparse matrices into relatively dense submatricestends to give state of the art practical performance for sparse matrix multiplication 。 自行感受下哈。从稀疏性的角度我也没理解很透。有大神有见解在评论补充下。所以Inception将传统CNN中卷积层的一个scale的卷积分解成多个scale的卷积,1*1+3*3+5*5等等。大概这样子做能降低数据的稀疏性。


    2. Separable convolution

    基于inception,xception提出了Separable convolution。假如说inception提取了feature map的width-wise 和height-wise的correlation,那么Separable convolution则是关注depth-wise层面。depth即是channel。如下图,传统的CNN卷积层,3*3的卷积核对所有channel都做卷积,但是Separable convolution则把channel维分成几段。每段由不同的卷积核处理。这就是所谓的Separable。


    3.Xception

    Xception则是多个Separable convolution的block叠加,再加上Resnet的residual connection。在Imagenet上,Xception比Inception V3高了一个点。更多的结果自己看论文吧。





    展开全文
  • GETTING STARTED  Tensors pytorch深度学习框架中的Tensor和...# 刚开始不明白这个未初始化是什么意思,明明赋值了啊,后来试验了多次 # 发现每次打印出来的值都不一样,有的非常大有的非常小,可能这里未初始...

    GETTING STARTED

     Tensors

    pytorch深度学习框架中的Tensor和numpy的操作类似,还可以在GPU上进行加速~

    import torch
    
    # Construct a 5x3 matrix, uninitialized
    # 刚开始不明白这个未初始化是什么意思,明明赋值了啊,后来试验了多次
    # 发现每次打印出来的值都不一样,有的非常大有的非常小,可能这里未初始化的意思
    # 就是指没有规律的意思吧
    x = torch.empty(5, 3)
    print(x)
    
    # 输出
    tensor([[8.3665e+22, 4.5580e-41, 1.6025e-03],
            [3.0763e-41, 0.0000e+00, 0.0000e+00],
            [0.0000e+00, 0.0000e+00, 3.4438e-41],
            [0.0000e+00, 4.8901e-36, 2.8026e-45],
            [6.6121e+31, 0.0000e+00, 9.1084e-44]])
    
    -------------------------------------------------------------------------------------
    
    # 随机初始化
    # 从[0,1)的均匀分布中采样
    x = torch.rand(5, 3)
    print(x)
    
    # 输出
    tensor([[0.1607, 0.0298, 0.7555],
            [0.8887, 0.1625, 0.6643],
            [0.7328, 0.5419, 0.6686],
            [0.0793, 0.1133, 0.5956],
            [0.3149, 0.9995, 0.6372]])
    
    -------------------------------------------------------------------------------------
    
    # 创建值全部为0的tensor,并定义数值类型
    x = torch.zeros(5, 3, dtype=torch.long)
    print(x)
    
    # 输出
    tensor([[0, 0, 0],
            [0, 0, 0],
            [0, 0, 0],
            [0, 0, 0],
            [0, 0, 0]])
    
    
    -------------------------------------------------------------------------------------
    
    # 指定data定义tensor
    x = torch.tensor([5.5, 3])
    print(x)
    
    # 输出
    tensor([5.5000, 3.0000])
    
    
    -------------------------------------------------------------------------------------
    
    # 基于已存在tensor来创建tensor(数值不一定相同,但size一定是相同的),这些方法可以重用输入tensor的性质,除非你重新指定,比如类型
    x = x.new_ones(5, 3, dtype=torch.double)      # new_* methods take in sizes
    print(x)
    
    x = torch.randn_like(x, dtype=torch.float)    # override dtype!  被新的类型覆盖
    print(x)                                      # result has the same size
    
    # 输出
    tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]], dtype=torch.float64)
    tensor([[-0.2217, -0.9135, -0.6010],
            [-0.3193, -0.3675,  0.1951],
            [ 0.0646, -0.4947,  1.0374],
            [-0.4154, -1.0247, -1.2872],
            [ 0.5228,  0.3420,  0.0219]])
    
    
    -------------------------------------------------------------------------------------
    # 获取size
    print(x.size())
    s = x.size()
    print(s)
    print(s[0])        # torch.Size实际上是一个元组,可以执行元组的所有操作
    
    # 输出
    torch.Size([5, 3])
    5

    Operations

    这里介绍一下tensor的操作

    # 以加法举例
    x = torch.ones(5, 3)
    y = torch.rand(5, 3)
    
    
    print(x + y)
    print(torch.add(x, y))
    
    result = torch.empty(5, 3)
    torch.add(x, y, out=result)     # 将输出结果赋给result
    print(result)
    
    
    #in-place
    # adds x to y
    # 其实y.add(x)也是可以相加的,但“_”的标识符意味着y的值会被改变
    y.add_(x)
    print(y)
    
    #以上所有打印的输出都是一样的
    tensor([[ 0.2349, -0.0427, -0.5053],
            [ 0.6455,  0.1199,  0.4239],
            [ 0.1279,  0.1105,  1.4637],
            [ 0.4259, -0.0763, -0.9671],
            [ 0.6856,  0.5047,  0.4250]])
    
    -------------------------------------------------------------------------------
    # torch.view是用来resize/reshape tensor
    x = torch.randn(4, 4)
    y = x.view(16)
    z = x.view(-1, 8)  # the size -1 is inferred from other dimensions
    print(x.size(), y.size(), z.size())
    
    # 输出
    torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])
    
    
    
    # 如果tensor仅有一个元素,使用.item()可以把值取出来
    x = torch.randn(1)
    print(x)
    print(x.item())
    
    # 输出
    tensor([1.9218])
    1.9218417406082153

    NUMPY和Tenosr互转

    Torch Tensor 和 NumPy array会共享底层内存位置,所以改变其中一个另一个值也会改变,举例:

    import torch
    import numpy as np
    
    
    a = torch.ones(5)
    print(a)
    b = a.numpy()         # tenor---->numpy
    print(b)
    
    # 输出
    tensor([1., 1., 1., 1., 1.])
    [1. 1. 1. 1. 1.]
    
    
    ----------------------------------------------------------------------------------
    
    # 改变tensor
    a.add_(1)
    print(a)
    print(b)          # array也会改变
    
    # 输出
    tensor([2., 2., 2., 2., 2.])
    [2. 2. 2. 2. 2.]
    
    
    ----------------------------------------------------------------------------------
    
    a = np.ones(5)
    b = torch.from_numpy(a)          # numpy------>tensor
    np.add(a, 1, out=a)
    print(a)
    print(b)        tensor也跟着改变
    
    
    # 输出
    [2. 2. 2. 2. 2.]
    tensor([2., 2., 2., 2., 2.], dtype=torch.float64)

    CUDA TENSORS

    使用.to方法把tensor移送到cpu或者gpu上

    x = torch.rand(5)
    if torch.cuda.is_available():
        device = torch.device("cuda")          # a CUDA device object
        y = torch.ones_like(x, device=device)  # directly create a tensor on GPU 
        # or just use strings ``.to("cuda")``
        # 相当于x.to("cuda")
        x = x.to(device)                       
        z = x + y
        print(z)
        # 将结果送到cpu上,还可以改变类型
        print(z.to("cpu", torch.double)) 
    
    
    # 输出
    tensor([1.4118, 1.2739, 1.6951, 1.7109, 1.4069], device='cuda:0')
    tensor([1.4118, 1.2739, 1.6951, 1.7109, 1.4069], dtype=torch.float64)
    

    NEURAL NETWORKS

    定义一个网络,例子:

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    
    class Net(nn.Module):
    
        def __init__(self):
            super(Net, self).__init__()
            # 1 input image channel, 6 output channels, 5x5 square convolution
            # kernel
            self.conv1 = nn.Conv2d(1, 6, 5)
            self.conv2 = nn.Conv2d(6, 16, 5)
            # an affine operation: y = Wx + b
            self.fc1 = nn.Linear(16 * 5 * 5, 120)
            self.fc2 = nn.Linear(120, 84)
            self.fc3 = nn.Linear(84, 10)
    
        def forward(self, x):
            # Max pooling over a (2, 2) window
            x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
            # If the size is a square you can only specify a single number
            x = F.max_pool2d(F.relu(self.conv2(x)), 2)
            x = x.view(-1, self.num_flat_features(x))
            x = F.relu(self.fc1(x))
            x = F.relu(self.fc2(x))
            x = self.fc3(x)
            return x
    
        def num_flat_features(self, x):
            size = x.size()[1:]  # all dimensions except the batch dimension
            num_features = 1
            for s in size:
                num_features *= s
            return num_features
    
    
    net = Net()
    print(net)
    
    params = list(net.parameters())
    print(len(params))       # w-b-w-b~~~~~依次,五层,所以输出为10
    print(params[0].size())  # conv1's .weight
    print(params[1].size())  # 偏置
    
    # 利用伪数据进行前向推断,维度依次为batchsize、图像通道、长宽
    input = torch.randn(1, 1, 32, 32)    
    out = net(input)
    print(out)
    
    # 输出
    # 直接就可以打印出每一层信息
    Net(
      (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
      (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
      (fc1): Linear(in_features=400, out_features=120, bias=True)
      (fc2): Linear(in_features=120, out_features=84, bias=True)
      (fc3): Linear(in_features=84, out_features=10, bias=True)
    )
    10
    torch.Size([6, 1, 5, 5])
    torch.Size([6])
    tensor([[ 0.1246, -0.0511,  0.0235,  0.1766, -0.0359, -0.0334,  0.1161,  0.0534,
              0.0282, -0.0202]], grad_fn=<ThAddmmBackward>)

    LOSS FUNCTION

    output = net(input)
    target = torch.randn(10)  # a dummy target, for example
    target = target.view(1, -1)  # make it the same shape as output
    criterion = nn.MSELoss()
    
    loss = criterion(output, target)
    print(loss)

    BACKPROP

    通过调用loss.backward()来进行反向误差传播,但在这之前要进行梯度清零,因为计算的梯度会累积起来,所以不清零的话下次减去的就是累积的梯度了,这是不对的!,举例:

    net.zero_grad()     # 梯度置为0
    
    print('BP之前的梯度')
    print(net.conv1.bias.grad)
    
    loss.backward()
    
    print('BP之后的梯度')
    print(net.conv1.bias.grad)
    
    #输出
    conv1.bias.grad before backward
    tensor([0., 0., 0., 0., 0., 0.])
    conv1.bias.grad after backward
    tensor([ 0.0181, -0.0048, -0.0229, -0.0138, -0.0088, -0.0107])

    UPDATE THE WEIGHTS

    参数更新公式:weight = weight - learning_rate * gradient

    这是最简单的更新形式,可以用简单的代码来实现:

    learning_rate = 0.01
    for f in net.parameters():
        f.data.sub_(f.grad.data * learning_rate)

    但这种写法封装程度不高,而且在实现Adam, RMSProp等的时候就很复杂了,还好pytorch提供了封装好的库,在torch.optim里面

    import torch.optim as optim
    
    # create your optimizer
    optimizer = optim.SGD(net.parameters(), lr=0.01)
    
    # in your training loop:
    optimizer.zero_grad()   # zero the gradient buffers
    output = net(input)
    loss = criterion(output, target)
    loss.backward()
    optimizer.step()    # Does the update

    TRAINING A CLASSIFIER

    以 CIFAR10 dataset为例子,介绍了如何读取、显示、训练、测试等操作

    1. Loading and normalizing CIFAR10

    import torch
    import torchvision
    import torchvision.transforms as transforms
    
    # 对图像进行规范化操作
    transform = transforms.Compose(
        [transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    
    trainset = torchvision.datasets.CIFAR10(root='E:/database/cifar-10', train=True,
                                            download=False, transform=transform)
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                              shuffle=True, num_workers=2)
    
    # testset = torchvision.datasets.CIFAR10(root='./data', train=False,
    #                                        download=True, transform=transform)
    # testloader = torch.utils.data.DataLoader(testset, batch_size=4,
    #                                          shuffle=False, num_workers=2)
    
    classes = ('plane', 'car', 'bird', 'cat',
               'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
    
    
    def imshow(img):
        img = img / 2 + 0.5     # unnormalize
        npimg = img.numpy()
        plt.imshow(np.transpose(npimg, (1, 2, 0)))
        plt.show()
    
    
    
    if __name__ == '__main__':
        # get some random training images
        dataiter = iter(trainloader)
        images, labels = dataiter.next()
    
        # show images
        imshow(torchvision.utils.make_grid(images))
        # print labels
        print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

                                                          

     

    import torch.nn as nn
    import torch.nn.functional as F
    import torch.optim as optim
    
    # 定义网络
    class Net(nn.Module):
        def __init__(self):
            super(Net, self).__init__()
            self.conv1 = nn.Conv2d(3, 6, 5)
            self.pool = nn.MaxPool2d(2, 2)
            self.conv2 = nn.Conv2d(6, 16, 5)
            self.fc1 = nn.Linear(16 * 5 * 5, 120)
            self.fc2 = nn.Linear(120, 84)
            self.fc3 = nn.Linear(84, 10)
    
        def forward(self, x):
            x = self.pool(F.relu(self.conv1(x)))
            x = self.pool(F.relu(self.conv2(x)))
            x = x.view(-1, 16 * 5 * 5)
            x = F.relu(self.fc1(x))
            x = F.relu(self.fc2(x))
            x = self.fc3(x)
            return x
    
    
    net = Net()
    
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
    
    # train~~
    for epoch in range(1):  # 1周期
    
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            # get the inputs
            inputs, labels = data
    
            # 梯度清零
            optimizer.zero_grad()
    
            # forward + backward + optimize
            outputs = net(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
    
            # verbose
            running_loss += loss.item()
            if i % 2000 == 1999:    # print every 2000 mini-batches
                print('[%d, %5d] loss: %.3f' %
                      (epoch + 1, i + 1, running_loss / 2000))
                running_loss = 0.0
    
    print('Finished Training')
    # 输出
    [1,  2000] loss: 2.191
    [1,  4000] loss: 1.868
    [1,  6000] loss: 1.684
    [1,  8000] loss: 1.588
    [1, 10000] loss: 1.524
    [1, 12000] loss: 1.487
    Finished Training
    
    
    # test
    correct = 0
    total = 0
    # 因为是测试,所以不需要计算梯度
    with torch.no_grad():
        for data in testloader:
            images, labels = data
            outputs = net(images)
            # 返回最大的数值和idx,这里我们只需要索引也就是predicted
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    
    print('Accuracy of the network on the 10000 test images: %d %%' % (
        100 * correct / total))
    # 输出
    Accuracy of the network on the 10000 test images: 47 %
    
    
    # 每个类别的正确率
    class_correct = list(0. for i in range(10))
    class_total = list(0. for i in range(10))
    with torch.no_grad():
        for data in testloader:
            images, labels = data
            outputs = net(images)
            _, predicted = torch.max(outputs, 1)
            # 这里squeeze()是取出维度是1的维度,但我试了两个一维tensor(labels也是一维的)
            # 结果是加上squeeze()和不加没区别,这里不知道是什么意思
            c = (predicted == labels).squeeze()
            for i in range(4):
                label = labels[i]
                class_correct[label] += c[i].item()
                class_total[label] += 1
    
    
    for i in range(10):
        print('Accuracy of %5s : %2d %%' % (
            classes[i], 100 * class_correct[i] / class_total[i]))
    
    # 输出
    Accuracy of plane : 43 %
    Accuracy of   car : 48 %
    Accuracy of  bird : 27 %
    Accuracy of   cat :  5 %
    Accuracy of  deer : 24 %
    Accuracy of   dog : 44 %
    Accuracy of  frog : 73 %
    Accuracy of horse : 67 %
    Accuracy of  ship : 78 %
    Accuracy of truck : 57 %
    
    

    TRAINING ON GPU

    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    # 将网络送入gpu
    net.to(device)
    # 输入和label也必须送入gpu
    inputs, labels = inputs.to(device), labels.to(device)

    以上代码都运行了,文档说,没有感觉到gpu的加速效果是因为网络太小了,这是必然的;我运行的时候发现,不是加速不明显的问题了,而是比cpu也慢很多,好吧,也难怪,毕竟不停的将数据送入显存,然后把结果送回cpu输出,是会很耗费开销!!!

    以上初次了解Pytorch,确实和keras,TF不一样,用pytorch感觉就真的像是在写普通的python代码,而TF、keras真的是无时无刻不感受框架的存在和限制!·~~~~~

    这些只是简介,更多的函数用法等还需要去查看教程文档~~

    参考

    https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html

    https://pytorch.org/tutorials/beginner/blitz/tensor_tutorial.html#numpy-bridge

    https://pytorch.org/docs/stable/torch.html?highlight=torch%20rand#torch.rand

    展开全文
  • 1. LSTM模型 输入参数理解 ...模型的调参是模型训练中非常重要的一部分,调整参数前的重要一步就是要理解参数是什么意思,才能帮助更好的调整参数。 但是发现在一些实战模型将代码直接放在那里,但是基本
  • Playing Atari with Deep Reinforcement Learning新收获问题残留--待解决1、强化学习中的online,offline,on-policy,off-policy是什么意思,有什么区别?2、卷积神经网络的参数啥的还没有弄明白。结束 本来打算把...


    本来打算把这篇文献翻译一下,然后再把自己的理解和问题写出来,但是百度一下,会发现有许多翻译,所以便把翻译的念头打消了,就写一下自己看这篇文献的收获和目前自己还存在的问题(以后把这些问题有解决的,会同步在这里更新的)。
    想看文献翻译的,推荐下面这个链接:link.

    一、新收获

    1、对文章段落的理解和收获

    abstract

    文章首次提出了一种可以成功学习到控制策略的深度学习模型,这种模型的输入直接来自于高维的使用强化学习的感官输入。模型是用Q-learning的一种变种方法训练的卷积神经网络,模型的输入是原始像素,输出是用来估计未来奖励的value function。

    (1)、introduction

    指出研究的现状,强化学习中一直存在的挑战:学会直接从高维的感官输入(比如视觉、语音)去控制智能体是强化学习长期存在的挑战。大部分成功应用强化学习的的例子都是依赖于人工提取特征。
    这时深度学习已经可以直接从原始发感官数据提取高维特征,使得在计算机视觉和语音识别上有了很大的突破。所以考虑把强化学习和深度学习进行结合,但是存在以下一些困难:
    (1)深度学习要求大量的有人工标签的训练数据,然而强化学习算法又必须从奖励(通常是稀疏的、有噪音的、有延迟的)这个标量中进行学习。
    (2)深度学习要求抽样的数据是相互独立的,但是强化学习是高度相关的状态序列。
    (3)强化学习中当算法采取新的行为的时候,数据会发生改变,而深度学习的数据是一个固定的分布。
    --------卷积神经网络可以克服这些困难。

    (3)、related work

    TD-gammon是首次把强化学习和深度学习结合一起使用的,用于训练backgammon这种游戏。他们使用的是类似于Q-learning的无模型的强化学习算法,用只有一个隐藏层的多层感知器估计value function。
    但是将TD-gammon这种训练方法用于chess,Go,和checkers这些游戏都没有成功,人们就人认为TD-gammon提出的这种方法只试用于backgammon这个游戏。
    后来人们发现,将无模型的强化学习算法与非线性函数逼近器或者与off policy学习结合试用会造成Q网络发散不收敛,而将无模型的学习算法与线性函数逼近器结合可以保证收敛。

    在以前的工作中,与本文算法相似的是neural fitted Q-learning:将深度学习与强化学习分开进行,先进行深度自动解码去学习低纬度的任务,然后将NFQ这种算法应用到这种画像。
    本文提出的算法是端到端的,神经网络的输入直接来自于视觉输入,让神经网络自己去提取特征。

    (4)、deep reinforcement learning

    区别于TD-gammon和online approach,本文提出一种experience replay新技术,将智能体之前走过的每一步et=(st,at,rt,st+1)都保存到数据集D中,当使用这些数据的时候,如果把这些历史数据的任意长度都输入到神经网络中有点苦难,所以这个时候提出了一个用来固定数据长度的函数。
    采用experience replay新技术有以下优点:
    (1)每一步的经验可以被用在多个权重更新中,这提高了数据效率。
    (2)随机从experience replay中抽样,打破了数据之间的相关性。
    (3)使用on-policy容易陷入局部最优甚至不收敛,使用experience replay之后,可以避免参数不收敛的现象。
    但是也存在一个缺点,在存储的数据集中,每组经验被抽取到的概率都是一样的,这样会导致重要的transition不能有更大的机会被抽取到。

    (4.1) preprocessing and model architecture

    直接使用原始像素(210160,每个都有128种颜色),在计算方面会带来很大的苦难,所以先进行预处理变成8484的灰色image。
    神经网络的输入有两种方法:
    (1)输入状态s和动作a,这样每换一个动作,都要从神经网络forward一次,如果动作很多的haunted会有很大的代价。
    (2)只输入状态s,这样只需forward一次神经网络就可以了。
    所以采用了第二种方法。
    然后就是神经网络结构的介绍,由于目前的能力有限,只能等重新更新了。

    (5)、experience

    这部分讲具体的试验过程及结果。
    将这种算法应用到7个试验当中,只有奖励函数进行了限制,其余的神经网络的结构什么的都没有改变,7个全部一样。奖励函数被改为只有-1,0,1这三个,这种改变有以下几点好处:
    (1)可以限制误差倒数的范围。
    (2)在多个游戏当中使用相同 的学习效率。
    (3)这样智能体不会由于不能区分不同等级的奖励而影响智能体的学习情况。

    (6)、conclusion

    state-of-the-art:最先进的

    2、问题与解答

    问题1:什么是end-to-end 的训练方式?
    解答:端到端的训练方式,就是说没有人工提取状态特征的过程,将游戏界面的原始像素直接做为神经网络的输入,让神经网络自己去提取状态特征。

    问题2:通过Q-Learning如何使用reward来构造标签,进行深度学习?
    解答:将利用 reward计算的目标Q值作为标签,当Q值无限接近于目标Q值时,我们的目的就达到了。

    二、问题残留–待解决

    1、强化学习中的online,offline,on-policy,off-policy是什么意思,有什么区别?

    在看上面翻译的时候,发现评论区说online与on-policy不一样,然后我就有点蒙了,应该是自己之前在理解方面存在错误,还重新把这个知识点尽心理解。

    2、卷积神经网络的参数啥的还没有弄明白。

    DQN使用了神经网络进行训练,神经网络由两层卷积层和两层全连接层构成,但是读到文章中关节模型结构的时候,发现有些参数不记得了,所以还得再把CNN、RNN等内容重新进行学习!

    发现自己脑袋好不管用啊,之前学过的东西,一段时间不用,就忘记了一大半了,这样的学习效率很低啊!大家有什么学习建议,也欢迎留言评论,我在这先谢过啦!!!

    三、结束

    以上内容如果哪里有不对的地方,欢迎留言指出,提建议!
    十分感谢您的观看,谢谢!

    展开全文
  • 首先看摘要,大概意思是深度神经网络太难训练啦,但我们的残差学习框架不一样,我们特别好训练,这是因为我们使用了&*%&*¥R……方法。而且我们的网络不仅好训练,精度还特别高,拿了好多比赛的冠军。它之...
  • Deep Active Learning(深度主动学习)

    千次阅读 2020-10-06 16:55:54
    大概的意思是:如果模型遇到了迷惑的地方,就主动的询问专家(这也是为什么要叫主动学习),然后由专家标定完,将这个标定了的新样本纳入到样本集中,再一起训练,这样可能逐步改善模型的困惑,同时一些模型已经学的...
  • 微调,在预训练的网络下进行微调,什么意思呢?就是当我有一个新的数据集时,希望我的网络能够更好的对我的数据进行预测的时候,就替换掉预训练好的网络模型中的一些数据,对一部分(通常是高层)或者是全部的层进行...
  • Deep Generative Model-part 1:深度生成模型-part 1 ...什么意思呢? 现在的机器学习是能够区分猫狗的不同了,但是,机器还是不能准确地画一只猫出来,所以我们现在就generate 一个模型出来。 2.Pixel RNN Pixel R
  • <div><p>第一列和第二列是什么意思?</p><p>该提问来源于开源项目:white127/QA-deep-learning</p></div>
  • 机器学习的评价指标:准确率...探究:软件工程中的test oracle到底是什么意思? Machine learningDeep learning的区别 Deep Learning vs Classical Machine Learning Svm算法原理及实现 what is the difference...
  • OpenCV调用TensorFlow是什么意思

    千次阅读 2019-02-21 21:38:30
    最近在看英文版的《Learning OpenCV 3》,看原书与看中文版相比,效率上不会有明显劣势,多了查单词的时间,但能更理解内容,翻译有时会省略一些显而易见但重要的细节,即翻译是从译者的角度,去理解、删减内容后再...
  • Learning of Deep Convolutional Feature Point Descriptors Edgar Simo-Serra, Eduard Trulls, Luis Ferraz, Iasonas Kokkinos, Pascal Fua, and Francesc Moreno-Noguer International Conference on Computer ...
  • 什么是OCR

    2017-12-10 20:46:22
    转载文章:http://lib.csdn.net/article/deeplearning/50604 OCR是英文Optical Character Recognition的缩写,意思是光学字符识别,也可简单地称为文字识别,是文字自动输入的一种方法。它通过扫描和摄像等光学...
  • OneFlow is a performance-centered and open-source deep learning framework. Install OneFlow System Requirements Python 3.6, 3.7, 3.8 CUDA Toolkit Linux x86_64 Driver CUDA runtime is statically ...
  • 神经网络开篇

    2016-11-01 23:14:11
    由于毕业设计选题的缘故——“卷积神经网络“课题,我现在需要阅读一份英文的文档,都是我不认识的人写的,名字叫《Neural networks and deep learning》,中文意思就是神经网络和深度学习,内容是什么?我也不清楚...
  • conda create -n DeepLearning python=3.8 或者通过Anaconda的方式新建(可能打开Anaconda的过程很漫长。。。。) 按照上图的方式,即可安装,但是不如命令来的快一些 现在出现了一写问题!!!! 我在新建虚拟...
  • 2.机器学习领域经常提到的特征是什么意思? 3.机器学习、表示学习、深度学习之间的关系是什么? 著名的桥水基金创始人Ray Dalio把人比作一部部机器,以及细胞、自然界的生物,也是作为世界中一个个机器在运行。而...
  • 深度学习(deeplearning),无疑是IT界近两年比较流行的一个热词。它是什么意思呢?理解起来,与人工智能、机器学习比较接近,目的是想让计算机能够像人脑一样智能地识别图片、语音……,因此无论是深度学习还是人工...
  • 【语义分割】全卷积网络-FCN

    千次阅读 2018-04-11 10:46:14
    什么是语义分割: 图像语义分割的意思就是机器自动...两种传统图像语义分割: 在 Deeplearning 技术快速发展之前,就已经有了很多做图像分割的技术,其中比较著名的是一种叫做 “Normalized cut” 的图划分方法,...
  • 因为在我deep learning的学习过程中,也一直有这样的问题。我一眼就能看懂作者的意思,他的想法就是:为什么我喂进了一张待预测的图片到训练好的网络中,网络输出的就是最终的预测结果。就比如说吧,现在是y
  • # 这是深度学习入门这本书里的一段代码,请问这个问题是什么意思以及怎样解决? 报错如下:(下面有源代码)Python 3.7.3 (default, Mar 27 2019, 17:13:21) [MSC v.1915 64 bit (AMD64)] on win32 runfile('E:/...

空空如也

空空如也

1 2
收藏数 28
精华内容 11
关键字:

deeplearning什么意思