pytorch教程龙曲良36-40

最新推荐文章于 2023-05-06 08:29:46 发布
最新推荐文章于 2023-05-06 08:29:46 发布
阅读量366 收藏 2
点赞数 1
分类专栏： pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sueong/article/details/116769086
版权

36函数极小值优化实战

四个解都是0所以都是全局最小值
在这里插入图片描述
在这里插入图片描述
PLOT

在这里插入图片描述

 #最小值0取的值（x,y）是（3,2）x初始化是0
#最小值0取的值（x,y）是（3.584428，-1.8484=126）x初始化是4

import os
os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'

import torch
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
#f(x,y)=(x**2+y-11)**2+(x+y**2-7)**2

def f(x):
    return (x[0]**2+x[1]-11)**2+(x[0]+x[1]**2-7)**2

x=np.arange(-6,6,0.1)
y=np.arange(-6,6,0.1)
print('x,y range:',x.shape,y.shape)
X,Y=np.meshgrid(x,y)
print('X,Y maps:',X.shape,Y.shape)#x,y两个平面对应位置上的点一一对应组成map
Z=f([X,Y])

fig=plt.figure('f')
ax=fig.gca(projection='3d')
ax.plot_surface(X,Y,Z)
ax.view_init(60,-30)
ax.set_xlabel('x')
ax.set_ylabel('y')
plt.show()

#现在是优化 pred对x的偏导 不是loss对w的偏导

x=torch.tensor([0.,0.],requires_grad=True)
optimizer=torch.optim.Adam([x],lr=1e-3)
#完成对x[0]'=x[0]-lr*pred对x[0]的偏导
#完成对x[1]'=x[1]-lr*pred对x[1]的偏导


for step in  range(20000):
    pred=f(x)

    optimizer.zero_grad()#反向传播累乘前先清零
    pred.backward()#生成x[0] x[1]的梯度信息
    optimizer.step()#更新一次x[0]' x[1]' 直到找到x[0]* x[1]*最合适的 满足最小值

    if step%2000==0:
        print('step {} ：x= {}，f(x)={}'.format(step,x.tolist(),pred.item()))
'''
x,y range: (120,) (120,)
X,Y maps: (120, 120) (120, 120)
step 0 ：x= [0.0009999999310821295, 0.0009999999310821295]，f(x)=170.0
step 2000 ：x= [2.3331806659698486, 1.9540694952011108]，f(x)=13.730916023254395
step 4000 ：x= [2.9820079803466797, 2.0270984172821045]，f(x)=0.014858869835734367
step 6000 ：x= [2.999983549118042, 2.0000221729278564]，f(x)=1.1074007488787174e-08
step 8000 ：x= [2.9999938011169434, 2.0000083446502686]，f(x)=1.5572823031106964e-09
step 10000 ：x= [2.999997854232788, 2.000002861022949]，f(x)=1.8189894035458565e-10
step 12000 ：x= [2.9999992847442627, 2.0000009536743164]，f(x)=1.6370904631912708e-11
step 14000 ：x= [2.999999761581421, 2.000000238418579]，f(x)=1.8189894035458565e-12
step 16000 ：x= [3.0, 2.0]，f(x)=0.0
step 18000 ：x= [3.0, 2.0]，f(x)=0.0

Process finished with exit code 0





'''

在这里插入图片描述

37logistics regression

regression一般是指的连续的值
转换成分类问题 加个sigmoid函数

在这里插入图片描述
在这里插入图片描述

classification：
目标：放大accuracy 越准确越好
pθ(y|x) 给出x得到y的条件概率,模型学到的概率
pr(y|x) 给出x得到y的条件概率,真实的概率
现在要法1缩小这二者的差距或者法2缩小二者的分布

为什么不能直接放大acc在这里插入图片描述
logistics regression：叫logistics是因为用了sigmoid函数，regression其实有争议，其实本质上是个classification问题 ，当使用MSE时可以理解成regression，但是用cross entropy就是classification问题

在这里插入图片描述

在这里插入图片描述
多分类问题在这里插入图片描述
经过softmax激活后，原来的输出大的变得更大
2->0.7，1->0.2 本来2/1=2倍现在0.7/0.2=3.5倍
在这里插入图片描述
在这里插入图片描述

38交叉熵

cross entropy

在这里插入图片描述

entropy
不确定性 惊喜 信息少

在这里插入图片描述

最后一个最稳定 所以熵很低，0.999的那个中奖
第一个熵最高不稳定会随机一个人中奖，都是0.25
熵最小，这个时候最有秩序；而被打乱的时候，熵开始增大，直到最后一片混乱，熵变成最大：
在这里插入图片描述
Dkl是kl Divergence 两个分布的重叠程度，数值越大重叠越少，数值越小重叠越大，如果pq完全相似则，Dkl就是0。

p=q时，Dkl=0，再有如果采用one-hot（分类问题多用这个），这样entropy=1log1=0，所以越稳定，所以可以用cross entropy衡量出来时
在这里插入图片描述

二分类问题的优化目标是-（ylog(p)+(1-y)log(1-p)）
在这里插入图片描述
使用cross entropy优化H下降速度更快，优化更快，pθ（预测分布）更接近pr（真实分布），比使用MSE更快
在这里插入图片描述
为啥不用MSE
1梯度消失
2梯度下降慢
3但是有时候用MSE效果更好 因为MSE梯度求导简单
（pred-y）**2 求导得2（pred-y）
在这里插入图片描述
在这里插入图片描述

注意cross entropy在pytorch中已经把softmax和log打包在一起，所以要传入的是logits
ce=softmax+log+nll_loss
在这里插入图片描述

39多分类问题实战

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

step是训练完一个batch的step
epoch是训练完整个数据集


'''
Train Epoch：0 [0/60000 (0%)]	 Loss:2.496092
Train Epoch：0 [20000/60000 (33%)]	 Loss:1.293757
Train Epoch：0 [40000/60000 (67%)]	 Loss:0.846965
Train Epoch：1 [0/60000 (0%)]	 Loss:0.627197
Train Epoch：1 [20000/60000 (33%)]	 Loss:0.580098
Train Epoch：1 [40000/60000 (67%)]	 Loss:0.486529
Train Epoch：2 [0/60000 (0%)]	 Loss:0.495914
Train Epoch：2 [20000/60000 (33%)]	 Loss:0.588657
Train Epoch：2 [40000/60000 (67%)]	 Loss:0.446819
Train Epoch：3 [0/60000 (0%)]	 Loss:0.447987
Train Epoch：3 [20000/60000 (33%)]	 Loss:0.384017
Train Epoch：3 [40000/60000 (67%)]	 Loss:0.367968
Train Epoch：4 [0/60000 (0%)]	 Loss:0.477522
Train Epoch：4 [20000/60000 (33%)]	 Loss:0.592025
Train Epoch：4 [40000/60000 (67%)]	 Loss:0.540704
Train Epoch：5 [0/60000 (0%)]	 Loss:0.448472
Train Epoch：5 [20000/60000 (33%)]	 Loss:0.445303
Train Epoch：5 [40000/60000 (67%)]	 Loss:0.489408
Train Epoch：6 [0/60000 (0%)]	 Loss:0.352725
Train Epoch：6 [20000/60000 (33%)]	 Loss:0.431580
Train Epoch：6 [40000/60000 (67%)]	 Loss:0.474489
Train Epoch：7 [0/60000 (0%)]	 Loss:0.550202
Train Epoch：7 [20000/60000 (33%)]	 Loss:0.415313
Train Epoch：7 [40000/60000 (67%)]	 Loss:0.369599
Train Epoch：8 [0/60000 (0%)]	 Loss:0.500460
Train Epoch：8 [20000/60000 (33%)]	 Loss:0.388243
Train Epoch：8 [40000/60000 (67%)]	 Loss:0.404500
Train Epoch：9 [0/60000 (0%)]	 Loss:0.397505
Train Epoch：9 [20000/60000 (33%)]	 Loss:0.351531
Train Epoch：9 [40000/60000 (67%)]	 Loss:0.443983

 test set:average loss：0.0003,Accuracy:8606/10000 (86)


Process finished with exit code 0

'''

40全连接层

多层的全连接层
nn.Linear

layer=nn.Linear(784,200)

在这里插入图片描述
大部分情况用relu 像素重建的时候才用sigmoid
在这里插入图片描述
autograd后实行自动向后求导
在这里插入图片描述
nn.Sequenltial可以添加任何继承nn.Module的类
class M

import torch
import torch.nn as nn

class MLP(nn.Module):
    def __init__(self):
        super(MLP,self).__init__()

        self.model=nn.Sequential(#sequential串联起来
            nn.Linear(784,200),
            nn.ReLU(inplace=True),
            nn.Linear(200, 200),
            nn.ReLU(inplace=True),
            nn.Linear(200,10),
            nn.ReLU(inplace=True),
        )
        def forward(self,x):
            x=self.model(x)

        return x

nn.ReLu是类api，需要先实例化再调用，w，b是内部参数不能介入只能使用.parameter来访问而不是私自访问
F.relu，function-api，可以自己管理w，b这些tensor，提供gpu操作
一般优先nn.ReLu

在这里插入图片描述
这里不用初始化w和b 因为w和b已经被Linear管理了，没办法直接暴露出来初始化，这个接口有自己的初始化方法已经够用了

# -*- codeing = utf-8 -*-
# @Time :2021/5/14 21:06
# @Author:sueong
# @File:ll.py
# @Software:PyCharm
import torch
import torch.nn as nn
from torch import optim

# 超参数
from torchvision import datasets, transforms

batch_size = 200
learning_rate = 0.01
epochs = 10

# 获取训练数据
train_db = datasets.MNIST('../data', train=True, download=True,  # train=True则得到的是训练集
                          transform=transforms.Compose([  # transform进行数据预处理
                              transforms.ToTensor(),  # 转成Tensor类型的数据
                              transforms.Normalize((0.1307,), (0.3081,))  # 进行数据标准化(减去均值除以方差)
                          ]))

# DataLoader把训练数据分成多个小组，此函数每次抛出一组数据。直至把所有的数据都抛出。就是做一个数据的初始化
train_loader = torch.utils.data.DataLoader(train_db, batch_size=batch_size, shuffle=True)

# 获取测试数据
test_db = datasets.MNIST('../data', train=False,
                         transform=transforms.Compose([
                             transforms.ToTensor(),
                             transforms.Normalize((0.1307,), (0.3081,))
                         ]))

test_loader = torch.utils.data.DataLoader(test_db, batch_size=batch_size, shuffle=True)


class MLP(nn.Module):
    def __init__(self):
        super(MLP,self).__init__()

        self.model=nn.Sequential(#sequential串联起来
            nn.Linear(784,200),
            nn.ReLU(inplace=True),
            nn.Linear(200, 200),
            nn.ReLU(inplace=True),
            nn.Linear(200,10),
            nn.ReLU(inplace=True),
        )
    def forward(self,x):
        x = self.model(x)
        return x



#Train

net=MLP()#网络结构 就是foward函数
optimizer=optim.SGD(net.parameters(),lr=learning_rate)#使用nn.Module可以直接代替之前[w1,b1,w2,b2.。。]
criteon=nn.CrossEntropyLoss()

for epoch in range(epochs):
    for batch_ind,(data,target) in enumerate(train_loader):
        data=data.view(-1,28*28)

        logits=net(data)#这不要再加softmax logits就是pred
        loss=criteon(logits,target)#求loss

        optimizer.zero_grad()
        loss.backward()

        optimizer.step()

        if batch_ind%100==0:
            print('Train Epoch：{} [{}/{} ({:.0f}%)]\t Loss:{:.6f}'.format(
                epoch,batch_ind*len(data),len(train_loader.dataset),
                100.* batch_ind/len(train_loader),loss.item()
            ))

test_loss=0
correct=0

for data,target in test_loader:
    data=data.view(-1,28*28)#第一个维度保持不变写-1
    logits=net(data)
    test_loss+=criteon(logits,target).item()

    pred=logits.data.max(1)[1]#因为
    correct+=pred.eq(target.data).sum()

test_loss/=len(train_loader.dataset)
print('\n test set:average loss：{:.4f},Accuracy:{}/{} ({:.0f}%)\n'.format(
    test_loss,correct,len(test_loader.dataset),
    100.*correct/len(test_loader.dataset)
))

'''
F:\anaconda\envs\pytorch\python.exe F:/pythonProject1/pythonProject3/ll.py
Train Epoch：0 [0/60000 (0%)]	 Loss:2.315060
Train Epoch：0 [20000/60000 (33%)]	 Loss:2.069264
Train Epoch：0 [40000/60000 (67%)]	 Loss:1.572258
Train Epoch：1 [0/60000 (0%)]	 Loss:1.299846
Train Epoch：1 [20000/60000 (33%)]	 Loss:1.100520
Train Epoch：1 [40000/60000 (67%)]	 Loss:1.019639
Train Epoch：2 [0/60000 (0%)]	 Loss:0.945382
Train Epoch：2 [20000/60000 (33%)]	 Loss:0.895289
Train Epoch：2 [40000/60000 (67%)]	 Loss:0.877365
Train Epoch：3 [0/60000 (0%)]	 Loss:0.826702
Train Epoch：3 [20000/60000 (33%)]	 Loss:0.817137
Train Epoch：3 [40000/60000 (67%)]	 Loss:0.667326
Train Epoch：4 [0/60000 (0%)]	 Loss:0.688401
Train Epoch：4 [20000/60000 (33%)]	 Loss:0.692957
Train Epoch：4 [40000/60000 (67%)]	 Loss:0.569227
Train Epoch：5 [0/60000 (0%)]	 Loss:0.667585
Train Epoch：5 [20000/60000 (33%)]	 Loss:0.588931
Train Epoch：5 [40000/60000 (67%)]	 Loss:0.531139
Train Epoch：6 [0/60000 (0%)]	 Loss:0.632487
Train Epoch：6 [20000/60000 (33%)]	 Loss:0.499388
Train Epoch：6 [40000/60000 (67%)]	 Loss:0.691728
Train Epoch：7 [0/60000 (0%)]	 Loss:0.435568
Train Epoch：7 [20000/60000 (33%)]	 Loss:0.600809
Train Epoch：7 [40000/60000 (67%)]	 Loss:0.525673
Train Epoch：8 [0/60000 (0%)]	 Loss:0.519194
Train Epoch：8 [20000/60000 (33%)]	 Loss:0.540513
Train Epoch：8 [40000/60000 (67%)]	 Loss:0.438987
Train Epoch：9 [0/60000 (0%)]	 Loss:0.427629
Train Epoch：9 [20000/60000 (33%)]	 Loss:0.409045
Train Epoch：9 [40000/60000 (67%)]	 Loss:0.514155

 test set:average loss：0.0004,Accuracy:8286/10000 (83%)


Process finished with exit code 0


'''
sueong
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
龙曲良版本的pytorch学习
aliuxuwhy的博客
08-18 965
1 权重参数的更新（Optimer.step()） ：根据上述计算的梯度值，不断进行权重参数得更新 参数优化目的：不断更新权重参数，使得损失值达到最小。 参数优化的方法：权重参数=权重参数-权重参数梯度学习率 损失值计算的方法：给定参数计算损失值； loss = inputw.t() +b – target 的平方 例子： 求 y=wx+b的参数，给100个点( x , y )； 解法：我们已知(x,y)的N个点，此时我们定义的损失函数如上所示，不断更新权重参数W和B，使得总损失值最小（根据已知的x,
Pytorch龙良曲实战代码与所遇问题解决
BAB__的博客
05-21 1011
本文为个人学习Pytorch龙良曲版本时跟写的代码，碍于版本、环境等诸多原因，原视频中代码不能直接照搬。针对自己所遇到的问题进行了改动，与大家分享共勉。
【龙良曲博士】深度学习与PyTorch-lesson63-自定义数据集
qq_45000512的博客
05-06 204
【代码】【龙良曲博士】深度学习与PyTorch-lesson63-自定义数据集。
2019最新pytorch教程
02-09
 这本书面向数据科学家、自然语言处理工程师、人工智能解决方案开发人员、从事图形计算框架的现有从业人员以及图论研究人员。这本书主要讲解张量（Tensor）的基础知识、计算、执行基于算术的运算、矩阵代数和使用PyTorch框架的基于统计分布式运算。
【龙良曲博士】深度学习与PyTorch-lesson5-手写数字问题
qq_45000512的博客
04-30 157
【代码】【龙良曲博士】深度学习与PyTorch-lesson5-手写数字问题。
pytorch-grad-cam-master.zip
05-29
在提供的"pytorch-grad-cam-master.zip"文件中，包含了实现Grad-CAM的PyTorch代码。这个项目可能包含了一个简单的图像分类网络，以及使用Grad-CAM可视化功能的脚本。通过运行这些代码，你可以观察到模型在处理不同...
a-PyTorch-Tutorial-to-Image-Captioning-master_pytorch_
09-30
本教程将引导你入门PyTorch，通过实例学习其基本原理和操作。 **基础原理知识** 1. **张量(Tensors)**：PyTorch的基础数据结构是张量，类似于多维数组。张量可以在CPU或GPU上运行，支持各种数学运算，如加法、乘法...
a-PyTorch-Tutorial-to-Image-Captioning:显示，参加和讲述| PyTorch教程以进行图像字幕
05-07
这是图像字幕的教程。 这是我正在编写的第一篇，是关于如何使用令人惊叹的PyTorch库自己实现酷模型的。 假定具备PyTorch，卷积和递归神经网络的基本知识。 如果您是PyTorch的新手，请先阅读PyTorch的和 。 问题...
PyTorch-Image-Models-Multi-Label-Classification-main.zip
03-26
PyTorch-Image-Models-Multi-Label-Classification-main.zip
Python库 | pytorch_lightning-1.1.2-py3-none-any.whl
05-09
资源分类：Python库 所属语言：Python 资源全名：pytorch_lightning-1.1.2-py3-none-any.whl 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
PyTorch 学习资源（代码类）
07-24
pytorch教程，代码类，分章节，共10章。
pytorch学习视频百度网盘链接.txt
02-23
pytorch学习视频，2.5个G。包括 深度学习初见/ 开发环境安装/ 回归问题/ pytorch基础教程/ pytorch进阶教程/ 随机梯度下降/ 神经网络与全连接层/ 过拟合/ 卷积神经网络CNN/ CIFAR10与resnet实战/ 循环神经网络RNN&lstm/
PyTorch-Course 代码+讲义+课件（B站最高播放量配套）
10-14
https://www.bilibili.com/video/BV12741177Cu?p=2，配套的讲义、课件PPT、源代码
pytorch教程龙曲良11-15
sueong的博客
05-11 338
11创建tensor02 randn一般是均值为0，方差为1的正态分布N(0,1)，也可以自定义N(u,std)用torch.normal torch.normal(mean=torch.full([10],0),std=torch.arange(1,0,-0.1)) #比如先把一个2*5的矩阵打平变成1*10，然后normal后再reshape为2*5 #torch.full先构建一个一维长度为10全是0的tensor，这样他们的mean就都是0 #torch.arange使得标准差std分布为[1,0.
pytorch（1）梯度下降
weixin_44950479的博客
12-23 1067
（1）梯度下降 1.什么是梯度下降 梯度gradient，是深度学习的核心精髓，许多专家称深度学习为gradient programming，deep learning其实就是求解一个巨复杂的函数，求解工具就是梯度下降算法。 梯度下降算法核心公式: xn+1= xn - f’(xn)* (learning rate) 其中learning rate通常取0.001，手写数据一般0.01。它的取值会...
龙良曲pytorch基础课程学习笔记
kexiaoleqq的博客
01-13 3771
什么是Pytorch? PyTorch 是一个基于 Python 的科学计算包，主要定位两类人群： NumPy 的替代品，可以利用 GPU 的性能进行计算 深度学习研究平台拥有足够的灵活性和速度 开始学习 tensor对象 在 TensorFlow 中，数据不是以整数，浮点数或者字符串形式存在的，而是被封装在一个叫做 tensor 的对象中。Tensor是张量的意思，张量包含了0到任意维度的量...
龙曲良 Tensorflow —— 神经网络与全连接层（自用）-3
清园暖歌的博客
02-14 1279
导入的格式是个 numpy 的api，所以可以直接 x.min()，不然 tensor 中是 tf.reduce_min。因为 cifar 大小非常小，所以图片会模糊，真实大小是 [32, 32, 3]x_test，y_test 为测试集：[10k, 32, 32]，[10k, 1]x_test，y_test 为测试集：[10k, 28, 28]，[10k, ]x，y 为训练集：[50k, 32, 32]，[50k, 1]x，y 为训练集：[60k, 28, 28]，[60k, ]
龙曲良 Tensorflow —— tensorflow基础操作（自用）-1
清园暖歌的博客
02-06 864
如下，[4， 28， 28， 3]，低于第一个28，我们不直接从A到B取索引，而是单独取其中的第3，27，9，13行，这就是切片indices，就用到了gather的功能，这里是取了4行，gather也就是收集的意思。如果 a，b 的 tensor 的 维度 dimension 不一致，如 [4,16,16,32] 和 [32] 相加，首先要把小维度对齐，左边大右边小，往前延伸插入维度，再把每个维度对齐，把1扩张为4，16。而下一种情况是对学生0的成绩都加5分，就是把每个班级前两个学生的每个科目都加5分。
pytorch教程龙曲良01-05
sueong的博客
05-08 699
01深度学习框架与介绍 pytorch优势 1使用gpu加速 # -*- codeing = utf-8 -*- # @Time :2021/5/6 20:51 # @Author:sueong # @File:grad.py # @Software:PyCharm import torch import time print(torch.__version__) print(torch.cuda.is_available()) a=torch.randn(10000,1000)#a矩阵 b=torch
pytorch-multi-label-classifier-master
最新发布
07-09
### 回答1： pytorch-multi-label-classifier-master是一个基于PyTorch的多标签分类器项目。该项目旨在使用PyTorch框架构建一个能够对具有多个标签的数据样本进行分类的模型。 PyTorch是一个流行的深度学习框架，能够实现多种深度学习模型的构建与训练。它提供了丰富的工具和函数，简化了模型的复杂性，并提供了高效的计算能力。 在这个项目中，multi-label指的是数据样本可以被分为多个标签。与传统的单标签分类不同，每个样本可以被分为多个类别，这增加了分类问题的复杂性。模型需要学习如何给每个样本分配正确的标签。 pytorch-multi-label-classifier-master项目提供了一个设置多标签分类模型的基础架构。它包含了数据预处理、模型构建、训练和评估等步骤。用户可以根据自己的数据集和需求，对该项目进行定制。 通过使用pytorch-multi-label-classifier-master项目，用户可以快速搭建一个多标签分类器，用于解决具有多个标签的数据分类问题。同时，该项目还提供了一些示例数据和模型，帮助用户更好地理解和使用多标签分类技术。 总而言之，pytorch-multi-label-classifier-master是一个基于PyTorch框架用于多标签分类的项目，为用户提供了一个简单且灵活的搭建多标签分类器的框架，方便用户解决多标签分类问题。 ### 回答2： pytorch-multi-label-classifier-master是一个基于PyTorch的多标签分类器项目。它提供了一种使用神经网络模型来处理多标签分类任务的解决方案。 该项目的主要目标是通过深度学习技术来提高多标签分类问题的准确度。它使用PyTorch作为深度学习框架，该框架提供了丰富的工具和功能来构建和训练神经网络模型。 在pytorch-multi-label-classifier-master中，你可以找到许多工具和函数来进行数据预处理、模型构建、训练和评估。它支持常见的多标签分类算法，如卷积神经网络（CNN）和递归神经网络（RNN）。你可以根据自己的需求选择合适的模型，并通过简单的配置来进行训练。 该项目还提供了一些示例数据集和预训练模型，以帮助你更快地开始。你可以使用这些数据集来测试和调试你的模型，或者使用预训练模型来进行迁移学习。 pytorch-multi-label-classifier-master还支持一些常见的性能评估指标，如准确率、精确率、召回率和F1值。你可以使用这些指标来评估你的模型在多标签分类任务上的性能。 总的来说，pytorch-multi-label-classifier-master是一个方便易用的项目，旨在帮助你构建和训练用于多标签分类的深度学习模型。它提供了丰富的功能和工具，使你能够快速搭建一个准确度较高的多标签分类器。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值