精华内容
下载资源
问答
  • 2016-07-27 16:30:38
    1.bagging 使用多个分类其结果进行投票,投票结果为分类结果
    2.ADABoost:将多个弱分类器合成一个较强的分类器

    转:bootstrps bagging boosting这几个概念经常用到,现仔细学习了一下:
    他们都属于集成学习方法,(如:Bagging,Boosting,Stacking),将训练的学习器集成在一起,原理来源于PAC学习模型(Probably Approximately CorrectK)。Kearns和Valiant指出,在PAC学习模型中,若存在一
    个多项式级的学习算法来识别一组概念,并且识别正确率很高,那么这组概念是强可学习的;而如果学习算法识别一组概念的正确率仅比随机猜测略好,那么这组概念是弱可学习的。他们提出了弱学习算法与强学习算法的等价性问题,即是否可以将弱学习算法提升成强学习算法。如果两者等价,那么在学习概念时,只要找到一个比随机猜测略好的弱学习算法,就可以将其提升为强学习算法,而不必直接去找通常情况下很难获得的强学习算法。
    bootstraps:名字来自成语“pull up by your own bootstraps”,意思是依靠你自己的资源,它是一种有放回的抽样方法,学习中还发现有种叫jackknife的方法,它是每一次移除一个样本。
    bagging: bootstrap aggregating的缩写。让该学习算法训练多轮,每轮的训练集由从初始的训练集中随机取出的n个训练倒组成,初始训练例在某轮训练集中可以出现多次或根本不出现训练之后可得到一个预测函数序列h.,⋯ ⋯h 最终的预测函数H对分类问题采用投票方式,对回归问题采用简单平均方法对新示例进行判别。
    (训练R个分类fi分类器之间其他相同就是参数不同。其中fi是通过从训练集合中(N篇文档)随机取(取后放回)N次文档构成的训练集合训练得到的 对于新文档d用这R个分类器去分类,得到的最多的那个类别作为d的最终类别.)
    boosting:其中主要的是AdaBoost(Adaptive Boosting)。初始化时对每一个训练例赋相等的权重1/n,然后用该学算法对训练集训练t轮,每次训练后,对训练失败的训练例赋以较大的权重,也就是让学习算法在后续的学习中集中对比较难的训练铡进行学习,从而得到一个预测函数序列h 一⋯h其中h.也有一定的权重,预测效果好的预测函数权重较大,反之较小。最终的预测函数H对分类问题采用有权重的投票方式,对回归问题采用加权平均的方法对新示例进行判别。( 类似Bagging方法,但是训练是串行进行的,第k个分类器训练时关注对前k-1分类器中错分的文档,即不是随机取,而是加大取这些文档的概率).
    Bagging与Boosting的区别:在于Bagging的训练集的选择是随机的,各轮训练集之间相互独立,而Boostlng的训练集的选择是独立的,各轮训练集的选择与前面各轮的学习结果有关;Bagging的各个预测函数没有权重,而Boosting是有权重的;Bagging的各个预测函数可以并行生成,而Boosting的各个预测函数只能顺序生成。对于象神经网络这样极为耗时的学习方法。Bagging可通过并行训练节省大量时间开销。   bagging和boosting都可以有效地提高分类的准确性。在大多数数据集中,boosting的准确性比bagging高。在有些数据集中,boosting会引起退化。---Overfit

    文本分类中使用的投票方法(Voting,也叫组合分类器)就是一种典型的集成机器学习方法。它通过组合多个弱分类器来得到一个强分类器,包括BaggingBoosting两种方式,二者的主要区别是取样方式不同。Bagging采用均匀取样,而Boosting根据错误率来取样,因此Boosting的分类精度要优于Bagging。投票分类方法虽然分类精度较高,但训练时间较长。Boosting思想的一种改进型AdaBoost方法在邮件过滤、文本分类方面都有很好的性能。



    from: http://home.kaoyan.com/space.php?uid=772709&do=blog&id=31082

    更多相关内容
  • svm多分类器详解

    万次阅读 2016-04-13 21:33:26
    如何由两类分类器得到分类器,就是一个值得研究的问题。 其中一种一劳永逸的方法,就是真的一次性考虑所有样本,并求解一个目标函数的优化问题,一次性得到个分类面。个超平面把空间划分为个区域,

    项目github地址:bitcarmanlee easy-algorithm-interview-and-practice
    欢迎大家star,留言,一起学习进步

    SVM是一种典型的两类分类器,即它只回答属于正类还是负类的问题。而现实中要解决的问题,往往是多类的问题(少部分例外,例如垃圾邮件过滤,就只需要确定“是”还是“不是”垃圾邮件),比如文本分类,比如数字识别。如何由两类分类器得到多类分类器,就是一个值得研究的问题。

    其中一种一劳永逸的方法,就是真的一次性考虑所有样本,并求解一个多目标函数的优化问题,一次性得到多个分类面。多个超平面把空间划分为多个区域,每个区域对应一个类别,给一篇文章,看它落在哪个区域就知道了它的分类。

    看起来很美对不对?只可惜这种算法还基本停留在纸面上,因为一次性求解的方法计算量实在太大,大到无法实用的地步。

    稍稍退一步,我们就会想到所谓“一类对其余”的方法,就是每次仍然解一个两类分类的问题。比如我们有5个类别,第一次就把类别1的样本定为正样本,其余2,3,4,5的样本合起来定为负样本,这样得到一个两类分类器,它能够指出一篇文章是还是不是第1类的;第二次我们把类别2 的样本定为正样本,把1,3,4,5的样本合起来定为负样本,得到一个分类器,如此下去,我们可以得到5个这样的两类分类器(总是和类别的数目一致)。到了有文章需要分类的时候,我们就拿着这篇文章挨个分类器的问:是属于你的么?是属于你的么?哪个分类器点头说是了,文章的类别就确定了。这种方法的好处是每个优化问题的规模比较小,而且分类的时候速度很快(只需要调用5个分类器就知道了结果)。但有时也会出现两种很尴尬的情况,例如拿一篇文章问了一圈,每一个分类器都说它是属于它那一类的,或者每一个分类器都说它不是它那一类的,前者叫分类重叠现象,后者叫不可分类现象。分类重叠倒还好办,随便选一个结果都不至于太离谱,或者看看这篇文章到各个超平面的距离,哪个远就判给哪个。不可分类现象就着实难办了,只能把它分给第6个类别了……更要命的是,本来各个类别的样本数目是差不多的,但“其余”的那一类样本数总是要数倍于正类(因为它是除正类以外其他类别的样本之和嘛),这就人为的造成了上一节所说的“数据集偏斜”问题。

    因此我们还得再退一步,还是解两类分类问题,还是每次选一个类的样本作正类样本,而负类样本则变成只选一个类(称为“一对一单挑”的方法,哦,不对,没有单挑,就是“一对一”的方法,呵呵),这就避免了偏斜。因此过程就是算出这样一些分类器,第一个只回答“是第1类还是第2类”,第二个只回答“是第1类还是第3类”,第三个只回答“是第1类还是第4类”,如此下去,你也可以马上得出,这样的分类器应该有5 X 4/2=10个(通式是,如果有k个类别,则总的两类分类器数目为k(k-1)/2)。虽然分类器的数目多了,但是在训练阶段(也就是算出这些分类器的分类平面时)所用的总时间却比“一类对其余”方法少很多,在真正用来分类的时候,把一篇文章扔给所有分类器,第一个分类器会投票说它是“1”或者“2”,第二个会说它是“1”或者“3”,让每一个都投上自己的一票,最后统计票数,如果类别“1”得票最多,就判这篇文章属于第1类。这种方法显然也会有分类重叠的现象,但不会有不可分类现象,因为总不可能所有类别的票数都是0。看起来够好么?其实不然,想想分类一篇文章,我们调用了多少个分类器?10个,这还是类别数为5的时候,类别数如果是1000,要调用的分类器数目会上升至约500,000个(类别数的平方量级)。这如何是好?

    看来我们必须再退一步,在分类的时候下功夫,我们还是像一对一方法那样来训练,只是在对一篇文章进行分类之前,我们先按照下面图的样子来组织分类器(如你所见,这是一个有向无环图,因此这种方法也叫做DAG SVM)

    这里写图片描述

    这样在分类时,我们就可以先问分类器“1对5”(意思是它能够回答“是第1类还是第5类”),如果它回答5,我们就往左走,再问“2对5”这个分类器,如果它还说是“5”,我们就继续往左走,这样一直问下去,就可以得到分类结果。好处在哪?我们其实只调用了4个分类器(如果类别数是k,则只调用k-1个),分类速度飞快,且没有分类重叠和不可分类现象!缺点在哪?假如最一开始的分类器回答错误(明明是类别1的文章,它说成了5),那么后面的分类器是无论如何也无法纠正它的错误的(因为后面的分类器压根没有出现“1”这个类别标签),其实对下面每一层的分类器都存在这种错误向下累积的现象。

    不过不要被DAG方法的错误累积吓倒,错误累积在一对其余和一对一方法中也都存在,DAG方法好于它们的地方就在于,累积的上限,不管是大是小,总是有定论的,有理论证明。而一对其余和一对一方法中,尽管每一个两类分类器的泛化误差限是知道的,但是合起来做多类分类的时候,误差上界是多少,没人知道,这意味着准确率低到0也是有可能的,这多让人郁闷。
      而且现在DAG方法根节点的选取(也就是如何选第一个参与分类的分类器),也有一些方法可以改善整体效果,我们总希望根节点少犯错误为好,因此参与第一次分类的两个类别,最好是差别特别特别大,大到以至于不太可能把他们分错;或者我们就总取在两类分类中正确率最高的那个分类器作根节点,或者我们让两类分类器在分类的时候,不光输出类别的标签,还输出一个类似“置信度”的东东,当它对自己的结果不太自信的时候,我们就不光按照它的输出走,把它旁边的那条路也走一走,等等。

    大Tips:SVM的计算复杂度
      使用SVM进行分类的时候,实际上是训练和分类两个完全不同的过程,因而讨论复杂度就不能一概而论,我们这里所说的主要是训练阶段的复杂度,即解那个二次规划问题的复杂度。对这个问题的解,基本上要划分为两大块,解析解和数值解。
      解析解就是理论上的解,它的形式是表达式,因此它是精确的,一个问题只要有解(无解的问题还跟着掺和什么呀,哈哈),那它的解析解是一定存在的。当然存在是一回事,能够解出来,或者可以在可以承受的时间范围内解出来,就是另一回事了。对SVM来说,求得解析解的时间复杂度最坏可以达到O(Nsv3),其中Nsv是支持向量的个数,而虽然没有固定的比例,但支持向量的个数多少也和训练集的大小有关。
    数值解就是可以使用的解,是一个一个的数,往往都是近似解。求数值解的过程非常像穷举法,从一个数开始,试一试它当解效果怎样,不满足一定条件(叫做停机条件,就是满足这个以后就认为解足够精确了,不需要继续算下去了)就试下一个,当然下一个数不是乱选的,也有一定章法可循。有的算法,每次只尝试一个数,有的就尝试多个,而且找下一个数字(或下一组数)的方法也各不相同,停机条件也各不相同,最终得到的解精度也各不相同,可见对求数值解的复杂度的讨论不能脱开具体的算法。
    一个具体的算法,Bunch-Kaufman训练算法,典型的时间复杂度在O(Nsv3+LNsv2+dLNsv)和O(dL2)之间,其中Nsv是支持向量的个数,L是训练集样本的个数,d是每个样本的维数(原始的维数,没有经过向高维空间映射之前的维数)。复杂度会有变化,是因为它不光跟输入问题的规模有关(不光和样本的数量,维数有关),也和问题最终的解有关(即支持向量有关),如果支持向量比较少,过程会快很多,如果支持向量很多,接近于样本的数量,就会产生O(dL2)这个十分糟糕的结果(给10,000个样本,每个样本1000维,基本就不用算了,算不出来,呵呵,而这种输入规模对文本分类来说太正常了)。
      这样再回头看就会明白为什么一对一方法尽管要训练的两类分类器数量多,但总时间实际上比一对其余方法要少了,因为一对其余方法每次训练都考虑了所有样本(只是每次把不同的部分划分为正类或者负类而已),自然慢上很多。

    展开全文
  • 利用pytorch实现多分类器

    千次阅读 2019-09-10 17:56:29
    训练分类器 就是这个。您已经了解了如何定义神经网络,计算损耗并更新网络权重。 现在你可能在想 数据怎么样? 通常,当您必须处理图像,文本,音频或视频数据时,您可以使用标准的python包将数据加载到numpy数组中...
    %matplotlib inline
    

    训练分类器

    就是这个。您已经了解了如何定义神经网络,计算损耗并更新网络权重。

    现在你可能在想

    数据怎么样?

    通常,当您必须处理图像,文本,音频或视频数据时,您可以使用标准的python包将数据加载到numpy数组中。然后你可以将这个数组转换成一个torch.*Tensor

    • 对于图像,Pillow,OpenCV等软件包很有用
    • 对于音频,包括scipy和librosa
    • 对于文本,无论是原始Python还是基于Cython的加载,还是NLTK和SpaCy都很有用
      特别是对于视觉,我们创建了一个名为的包 torchvision,其中包含用于常见数据集的数据加载器,如Imagenet,CIFAR10,MNIST等,以及用于图像的数据转换器,即 torchvision.datasetstorch.utils.data.DataLoader

    这提供了极大的便利并避免编写样板代码。

    在本教程中,我们将使用CIFAR10数据集。它有类:‘飞机’,‘汽车’,‘鸟’,‘猫’,‘鹿’,‘狗’,‘青蛙’,‘马’,‘船’,‘卡车’。CIFAR-10中的图像尺寸为3x32x32,即尺寸为32x32像素的3通道彩色图像。

    cifar10

    cifar10

    训练图像分类器

    我们将按顺序执行以下步骤:

    • 使用加载和标准化CIFAR10训练和测试数据集 torchvision
    • 定义卷积神经网络
    • 定义损失函数
    • 在训练数据上训练网络
    • 在测试数据上测试网络

    加载和标准化CIFAR10

    使用torchvision,加载CIFAR10非常容易。

    import torch
    import torchvision
    import torchvision.transforms as transforms
    

    torchvision数据集的输出是范围[0,1]的PILImage图像。我们将它们转换为归一化范围的张量[-1,1]

    Note

    If running on Windows and you get a BrokenPipeError, try setting the num_worker of torch.utils.data.DataLoader() to 0.

    transform = transforms.Compose(
        [transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    
    trainset = torchvision.datasets.CIFAR10(root='./data', train=True,##数据集的数据加载器,train=True时使用训练集,False时为使用测试集
                                            download=True, transform=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')
    
    Downloading http://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data\cifar-10-python.tar.gz
    Files already downloaded and verified
    

    让我们展示一些训练图像,以获得乐趣。

    import matplotlib.pyplot as plt
    import numpy as np
    
    # functions to show an image
    
    
    def imshow(img):
        img = img / 2 + 0.5     # unnormalize
        npimg = img.numpy()
        plt.imshow(np.transpose(npimg, (1, 2, 0)))
        plt.show()
    
    
    # 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)))
    

    [外链图片转存失败(img-tdbXaAP1-1568109363235)(output_7_0.png)]

     ship plane  ship  deer
    

    定义卷积神经网络

    从神经网络部分复制神经网络并修改它以获取3通道图像(而不是定义的1通道图像)。

    import torch.nn as nn
    import torch.nn.functional as F
    
    
    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()
    

    定义Loss函数和优化器

    让我们使用分类交叉熵损失和SGD动量。

    import torch.optim as optim
    
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
    

    训练网络

    事情开始变得有趣了。我们只需循环遍历数据迭代器,并将输入提供给网络并进行优化。

    for epoch in range(2):  # loop over the dataset multiple times
    
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            # get the inputs; data is a list of [inputs, labels]
            inputs, labels = data
    
            # zero the parameter gradients
            optimizer.zero_grad()
    
            # forward + backward + optimize
            outputs = net(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
    
            # print statistics
            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.168
    [1,  4000] loss: 1.833
    [1,  6000] loss: 1.693
    [1,  8000] loss: 1.589
    [1, 10000] loss: 1.527
    [1, 12000] loss: 1.488
    [2,  2000] loss: 1.418
    [2,  4000] loss: 1.371
    [2,  6000] loss: 1.355
    [2,  8000] loss: 1.331
    [2, 10000] loss: 1.300
    [2, 12000] loss: 1.292
    Finished Training
    

    在测试数据上测试网络

    我们已经在训练数据集上训练了2次。但我们需要检查网络是否已经学到了什么。

    我们将通过预测神经网络输出的类标签来检查这一点,并根据地面实况进行检查。如果预测正确,我们将样本添加到正确预测列表中。

    好的,第一步。让我们从测试集中显示一个图像以熟悉。

    dataiter = iter(testloader)
    images, labels = dataiter.next()
    
    # print images
    imshow(torchvision.utils.make_grid(images))
    print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
    

    [外链图片转存失败(img-NPfLQZwH-1568109363236)(output_15_0.png)]

    GroundTruth:    cat  ship  ship plane
    

    好的,现在让我们看看神经网络认为上面这些例子是什么:

    outputs = net(images)
    

    输出是10类的精度。一个类的精度越高,网络认为图像是特定类的越多。那么,让我们得到最高精度的指数:

    _, predicted = torch.max(outputs, 1)
    
    print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
                                  for j in range(4)))
    
    Predicted:    cat  ship  ship  ship
    

    结果似乎很好。

    让我们看看网络如何在整个数据集上执行。

    correct = 0
    total = 0
    with torch.no_grad():
        for data in testloader:
            images, labels = data
            outputs = net(images)
            _, 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: 52 %
    

    这看起来好于偶然,这是10%的准确性(从10个班级中随机挑选一个班级)。似乎网络学到了一些东西。

    嗯,什么是表现良好的类,以及表现不佳的类:

    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)
            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 : 34 %
    Accuracy of   car : 43 %
    Accuracy of  bird : 38 %
    Accuracy of   cat : 39 %
    Accuracy of  deer : 57 %
    Accuracy of   dog : 57 %
    Accuracy of  frog : 58 %
    Accuracy of horse : 55 %
    Accuracy of  ship : 73 %
    Accuracy of truck : 67 %
    
    展开全文
  • SVM多分类器的实现(Opencv3,C++)

    万次阅读 多人点赞 2016-12-13 15:44:43
    SVM多分类器的Opencv实现

    之前说要用SVM实现表情识别来着,所以找个简单例子练练手。


    惯例开始放结果,实现结果如下:

    //这里简单对四个点分了四类,图片显示得很直观。

    //支持向量总共6个。

    //最后测试了两个点进行分类。



    只需要配置好Opencv3的环境即可运行。

    这里用到的是cv::SVM, 老版本Opencv2410之前用的是CvSvm,推荐用最新的Opencv310。


    配置环境链接:

    //代码的备注自我感觉写得挺多啦

    下面就是简单粗暴的代码啦:

    #include<opencv2\opencv.hpp> 
    
    using namespace std;
    using namespace cv;
    using namespace cv::ml;
    
    int main()
    {
    
    
    	//训练需要用到的数据
    	int 标签[4] = { 1, 2, 3, 4 };
    	float 训练数据[4][2] = { { 31, 12 },{ 65, 220 },{ 440, 350 },{ 400, 400 } };
    	//转为Mat以调用
    	Mat 训练Mat(4, 2, CV_32FC1, 训练数据);
    	Mat 标签label(4, 1, CV_32SC1, 标签);
    	//训练的初始化
    	Ptr<SVM> svm = SVM::create();
    	svm->setType(SVM::C_SVC);
    	svm->setKernel(SVM::LINEAR);
    	svm->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER, 100, 1e-6));
    	//开始训练
    	svm->train(训练Mat, ROW_SAMPLE, 标签label);
    
    	//-----------无关紧要的美工的部分-----------------------	
    	//----其实对每个像素点的坐标也进行了分类----------------
    	int 宽 = 512, 高 = 512;
    	Mat 演示图片 = Mat::zeros(高, 宽, CV_8UC3);
    	Vec3b green(0, 255, 0), blue(255, 0, 0), red(0, 0, 255), black(0, 0, 0);
    	for (int i = 0; i < 演示图片.rows; ++i)
    		for (int j = 0; j < 演示图片.cols; ++j)
    		{
    			Mat sampleMat = (Mat_<float>(1, 2) << j, i);
    			float response = svm->predict(sampleMat);
    
    			if (response == 1)
    				演示图片.at<Vec3b>(i, j) = green;
    			else if (response == 2)
    				演示图片.at<Vec3b>(i, j) = blue;
    			else if (response == 3)
    				演示图片.at<Vec3b>(i, j) = red;
    			else if (response == 4)
    				演示图片.at<Vec3b>(i, j) = black;
    		}
    	//--------把初始化训练的点画进图片------------
    	int thickness = -1;
    	int lineType = 8;
    	for (int 画点 = 0; 画点 < sizeof(标签) / sizeof(int); 画点++) {
    		circle(演示图片, Point(训练数据[画点][0], 训练数据[画点][1]), 10, Scalar(255, 255, 255), thickness, -1);
    	}
    	// 把 support vectors  cout粗来看看……
    	Mat sv = svm->getSupportVectors();
    	cout << "Support Vectors为:" << endl;
    	for (int i = 0; i < sv.rows; ++i)
    	{
    		const float* v = sv.ptr<float>(i);
    		cout << v[0] << " " << v[1] << endl;
    	}
    
    	//测试测试
    
    	Mat 结果;
    	float teatData[2][2] = { { 20, 11 },{ 310, 411 } };
    	Mat query(2, 2, CV_32FC1, teatData);
    
    	svm->predict(query, 结果);
    	cout << "分类结果为:" << endl;
    	cout << 结果;
    	imshow("SVM显示", 演示图片);
    	waitKey(-1);
    
    }

    祝大家使用分类器愉快咯,有问题欢迎留言交流哈~



    展开全文
  • 系统学习机器学习之组合多分类器

    万次阅读 2015-12-29 11:01:55
    一般来说,我们可以针对同一个数据集使用个机器学习算法,然后比较算法的契合度,基本就是准确率,然后选择最合适的一个。但是也存在一些情况,所有单个算法都不能达到我们预期的准确率,此时我们就要考虑组合学习...
  • 多分类器-----Multiclass classification

    千次阅读 2016-07-18 10:58:17
    之前讲过线性分类器可以解决二分类的问题。...通过分类器我们就可以划分出个类了。那么这种思想还不完善,存在什么问题呢? 对于某一些区域的点来说分类器都抢着说这是我的类,对于有的区域大家又都说不是我
  • 本文在CIFAR-10数据集上举例。CIFAR-10的训练集有50000张32*32*3...一个机器学习(包括深度学习)多分类器的生命周期包括3大模块: 1.Score Function: 将3072维的input xi转化成一个10维的classfication score ve...
  • 自己动手实现一个神经网络多分类器

    万次阅读 多人点赞 2018-09-12 09:59:25
    不使用任何深度学习框架,实现一个简单的神经网络用来分类。 手把手带你搭建神经网络,包括损失函数的选择,已经手写反向传播代码。 生成一些数据 生成一些数据,这些数据不太容易线性分类。 import numpy ...
  • 分类器解决分类问题

    千次阅读 2019-05-14 16:38:20
    两种思路: 以SVM为例 1.one-versus-rest 思想: 假设一共有1,2,3,4,5个类别的数据 ...在预测阶段,对于输入的待分类样本,分别从第一个分类器开始询问是否属于该类别,该分类器“承认”,就将该样本...
  • 主要的两种策略是:一对方法;一对一方法。 一对一方法是在任意两类样本之间设计创建一个二值分类器,对每一个样本都需要用所有的二值分类器进行分类,...另外一种实现分类器的方法是一对,其为每类创建...
  • 借助标签分类器进行对抗训练

    千次阅读 2022-01-21 12:01:04
    目前对抗训练的研究方向主要集中在分类任务中的训练方式上,本文尝试借助标签分类器来对多分类器进行对抗训练,其中分类任务和标签任务的区别可以从文章《标签分类器(附pytorch代码)》中知晓。...
  • Matlab 实现线性svm两类和分类器

    万次阅读 多人点赞 2018-01-18 21:59:43
    线性分类和SVM原理 网上有很写的好的博客讲解线性分类和SVM,本人讲解能力差,就...训练svm分类器实际上是解二次规划问题,matlab里用到的是quadprog函数,其使用用法可参见matlab官方文档: http://cn.mathworks.co
  • 投票分类器模型是一种很常用的模型,在很外文论文中次见到,诸如随机森林这般强悍的分类器核心的思想就是:投票。投票分类器简单来说并不是一种固定具体的分类器模型,而是一种框架,在这种框架里面可以套用...
  • 贝叶斯分类器

    万次阅读 多人点赞 2018-07-27 22:22:41
    贝叶斯分类器是一类分类算法的总称,这类算法均以贝叶斯定理为基础,故统称为贝叶斯分类器。而朴素贝叶斯分类器是贝叶斯分类器中最简单,也是最常见的一种分类方法。并且,朴素贝叶斯算法仍然是流行的十大挖掘算法之...
  • SVM实现多分类

    千次阅读 2019-03-20 21:18:09
    SVM算法最初是为二值分类问题设计的,当处理类问题时,就需要构造合适的分类器。目前,构造SVM分类器的方法主要有两类:直接法 和 间接法。 1. 直接法 直接在目标函数上进行修改,将个分类面的参数求解...
  • 车辆检测分类器文件

    千次下载 热门讨论 2014-06-26 10:12:28
    博文:http://blog.csdn.net/zhuangxiaobin/article/details/25476833 这篇文章里所提供的工具和样本训练出来的分类器xml文件,可以使用文中的代码实践一下
  •  (2)间接法,主要是通过组合个二分类器来实现多分类器的构造,常见的方法有one-against-one和one-against-all两种。 一对法(one-versus-rest,简称OVR SVMs)  训练时依次把某个类别的样本归为一类,其他...
  • 也就是对于任何一个分类任务,训练n个弱分类器,也就是分类准确度只比随机猜好一点,那么当n足够大的时候,通过投票机制,也能提升很大的准确度:毕竟每个网络都分错同一个数据的可能性会降低。 接下来就是代码实现...
  • SVM分类器(matlab)

    万次阅读 多人点赞 2018-07-22 22:48:51
    支持向量机(Support Vector Machine,SVM),可以完成对数据的分类...首先,对于SVM来说,它用于二分类问题,也就是通过寻找一个分类线(二维是直线,三维是平面,多维是超平面)可以将数据分为两类。 并用线性函数...
  • SVM分类器详解

    万次阅读 多人点赞 2016-12-05 20:49:56
    二是置信风险,代表了我们在大程度上可以信任分类器在未知文本上分类的结果。很显然,第二部分是没有办法精确计算的,因此只能给出一个估计的区间,也使得整个误差只能计算上界,而无法计算准确的值(所以叫做泛化...
  • Svm实现多分类

    万次阅读 多人点赞 2019-05-14 17:17:23
    Svm实现分类Svm实现类分类原理...量机分类器的方法主要有两类: 一类是“同时考虑所有分类”方法,另一类是组合二分类器解诀分类问题。 第一类方法主要思想是在优化公式的同时考虑所有的类别数据,J.Weston 和...
  • 理解高斯分类器

    千次阅读 2019-06-20 08:37:13
    在本文中,我们讨论了单变量和变量正态分布,以及如何使用贝叶斯定理导出高斯分类器。像高斯这样的分类器简单而直观,并且可以解释。 正态/高斯分布 在现实生活中,我们总是会对某些现象产生不确定性...
  • ROC(Receiver Operating Characteristic) 曲线和AUC(Area Under the Curve) 值常被用来评价一个二值分类器 (binary classifier) 的优劣 分类问题评价指标:precision,recall,F-score 在分类任务中,人们总是...
  • 数据分类器构建

    万次阅读 2022-03-05 15:15:53
    要求完成分类器的代码实现 二、内容 KNN分类方法的实现 三、实验步骤 X=standdata; [n,m]=size(X); x=rand(1,m-1); %%x和X每一行向量的距离: for i=1:n %%x和X每一行向量的距离 dis(i)=sqrt((x-X(i,1:m...
  • 一个分类器的分类准确率在60%-80%,即:比随机预测略好,但准确率却不太高,我们可以称之为“弱分类器”,比如CART(classification and regression tree分类与回归树)。 反之,如果分类精度90%以上,则是强分类...
  • Matlab中的六种分类器

    万次阅读 2018-04-25 18:01:24
    首先,对于所有分类器,先将数据属性归一化。在下文中,训练数据标签为train_label (nx1向量,n为训练样本数量),训练数据属性为train_data(nx4矩阵,n为训练数据数量);测试数据标签为test_label (nx1向量,n为...
  • 分类多分类问题的评价指标总结

    万次阅读 多人点赞 2019-07-09 18:51:55
    分类评价指标 准确率(Accuracy) 评价分类问题的性能指标一般是分类准确率,即对于给定的数据,分类正确的样本数占总样本数的比例。 注意:准确率这一指标在Unbalanced数据集上的表现很差,因为如果我们的正负...
  • Scikit-Learn 随机森林分类器的使用

    万次阅读 2016-11-23 15:43:31
    随机森林(RandomForest), 指的是利用棵树对样本进行训练并预测的一种分类器。该分类器最早由Leo Breiman和Adele Cutler提出,并被注册成了商标。简单来说,随机森林就是由棵CART(Classification And ...
  • 原文链接:http://www.wangxianfeng.name/2011/08/ensemble-method-to-improve-the-accuracy-of-the-classifier/ 传统的分类方法是在一个由各种可能的函数构成的空间中寻找一个最...可以通过聚集分类器的预测

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 820,995
精华内容 328,398
关键字:

多分类器

友情链接: 871645.zip