精华内容
下载资源
问答
  • 方案一: 设置bn层参数不可变 K.set_learning_phase(0) base_model = tf.keras.applications.ResNet50(weights='imagenet', include_top=False, input_shape=(img_resize, img_resize, 3), ) # 设置bn层参数可变 ...

    方案一:

    设置bn层参数不可变

    K.set_learning_phase(0)
    base_model = tf.keras.applications.ResNet50(weights='imagenet', include_top=False,
                                      input_shape=(img_resize, img_resize, 3), )
    # 设置bn层参数可变
    K.set_learning_phase(1)
    model=tf.keras.Sequential()
    model.add(base_model)
    model.add(tf.keras.layers.GlobalAveragePooling2D())
    model.add(tf.keras.layers.Dense(512,activation="relu"))
    #model.add(tf.keras.layers.Dense(512,activation="relu",kernel_regularizer=tf.keras.regularizers.l2(0.0001)))
    model.add(tf.keras.layers.Dense(1,activation="sigmoid"))
    model.compile(optimizer=tf.keras.optimizers.Adam(lr=0.0001),loss="binary_crossentropy",metrics=["acc"])
    history=model.fit(train_ds2,epochs=5,validation_data=test_ds2)
    

    方案二:

    K.set_learning_phase(0)
    base_model = tf.keras.applications.ResNet50(weights='imagenet', include_top=False,input_shape=(img_resize, img_resize, 3) )
    # 不要设置成False,否则会影响训练效果(冻结训练的代码一定要在这个位置写)
    base_model.trainable=False
    K.set_learning_phase(1)
    x=base_model.output
    x=tf.keras.layers.GlobalAveragePooling2D()(x)
    x=tf.keras.layers.Dense(512,activation="relu")(x)
    x=tf.keras.layers.Dense(1,activation="sigmoid")(x)
    model = tf.keras.Model(inputs=base_model.input, outputs=x)
    
    展开全文
  • 2020/5/9 日记录 ...2. 随着epoch迭代,验证集准确率val_acc保持不变了!这不就是传说中过拟合的征兆吗?引用另一篇博客的话 :“我们之前把数据切分为训练,测试验证集验证集就是用来检测模型ove

    2020/5/9 日记录

    今天解决了acc 和val_acc一直为1.000的奇怪问题之后(原来是label标错了o(╥﹏╥)o),终于走上了正式的调参之路。
    先看一下训练结果:在这里插入图片描述
    可以看到:
    1.验证集准确率val_acc>训练集准确率train_acc。查资料,属于正常情况,不过也有可能有一些问题,先观察着。
    2. 随着epoch迭代,验证集准确率val_acc保持不变了!这不就是传说中过拟合的征兆吗?引用另一篇博客的话 :“我们之前把数据集切分为训练集,测试集和验证集。验证集就是用来检测模型overfitting。
    一旦在验证集上,准确性不在变化(收敛了),那么我们就停止训练。”

    在程序中已经设置了早停earlystoping ,是这样写的:

      # 是否需要早停,当val_loss一直不下降的时候意味着模型基本训练完毕,可以停止
        early_stopping = EarlyStopping(
                                monitor='val_loss', 
                                min_delta=0, 
                                patience=10, 
                                verbose=1
                            )
    

    是以val_loss为监测标准的。min_delta 代表的是容忍度,val_loss最少要下降所少才算数。这里设置的是0,也就是说,只要下降,哪怕是0.0000001也算数,不会停止训练,还是会继续下一个epoch训练。

    看这连续4个epoch,val_acc都不变,过拟合实锤了。现在要解决的问题:

    val_acc保持不变是怎么个情况?好不好?怎么解决?有可能是什么原因?

    以下转载自知乎https://zhuanlan.zhihu.com/p/92729376

    “ loss不收敛包含两种情况,一种是loss一直在震荡,一种是loss下降一点后不再下降到理想水平,而验证集上的表现保持不变.”
    采取措施如下:

    "1.保持需要的batchsize不变;
    2.查看是否有梯度回传,查看代码如下:

    for name, parms in model.named_parameters():
    	print('-->name:', name, '-->grad_requirs:', parms.requires_grad, '--weight', torch.mean(parms.data), ' -->grad_value:', torch.mean(parms.grad))
    

    3.查看数据是否有问题,如标签错乱等现象;
    4.调节学习率,从大向小调,建议每次除以5;我的项目即是因为学习率过大过小都不收敛引起的;
    5.如果学习率调好后,需要调节batchsize大小,如batchsize调大2倍,则将学习率对应调大(项目测试调大2~3倍OK),反之,学习率对应调小"

    总的来说:调参吧。

    于是:将学习率初始值改为0.0001,竟然意外地好用:

    展开全文
  • 在训练网络时,查看对测试准确率,一直很低且不变(也就是网络并没有学习)的原因是什么? ![图片说明](https://img-ask.csdn.net/upload/201904/22/1555914342_756745.png) 是迭代次数比较少吗?前200次迭代...
  • 训练集准确率很高,验证集准确率低问题

    万次阅读 多人点赞 2020-10-08 17:01:57
    验证集准确率没有升高,一直维持在50%左右(二分类问题,随机概率) 测试集准确率57% 在网上搜索可能打的原因: 1.learning rate太小,陷入局部最优 2.训练和测试数据没有规律 3.数据噪声太大 4.数据量太小...

    训练集在训练过程中,loss稳步下降,准确率上升,最后能达到97%
    验证集准确率没有升高,一直维持在50%左右(二分类问题,随机概率)
    测试集准确率57%

    在网上搜索可能打的原因:
    1.learning rate太小,陷入局部最优

    2.训练集和测试集数据没有规律

    3.数据噪声太大

    4.数据量太小(总共1440个样本,80%为训练集)

    5.训练集和测试集数据分布不同:如训练集正样本太少(如果训练集和测试集每次运行随机选择,则排除)

    6.数据集存在问题,如标注有问题(如采用公开数据集,则排除)

    7.学习率过大

    8.模型参数量过多而数据量过少

    9.过拟合,数据量太小但是模型的结构较为复杂
    解决办法:降低模型的复杂度,增大L2正则项,在全连接层加入Dropout层;有了dropout,网络不会为任何一个特征加上很高的权重(因为那个特征的输入神经元有可能被随机删除),最终dropout产生了收缩权重平方范数的效果

    10.输入到网络中的特征有问题,特征与label之间没有很明确的关联,或特征太少

    11.数据没有归一化

    12.修改学习率,使得每次梯度下降低于某个值或者停止下降时,降低学习率,来使得梯度进一步下降。(我使用该方法,使得问题得到解决)

    针对第12点,修改学习率的举例如下:(基于pytorch)

    optimizer = torch.optim.SGD(model.parameters(), lr=0.1)  # 优化器
    scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)  # 设定优优化器更新的时刻表
    
    def train(...):
        for i, data in enumerate(train_loader):     
            ......
            y_ = model(x)   
            loss = criterion(y_,y)     
    		optimizer.zero_grad()     
            loss.backward()             
            optimizer.step()            
            ......
     # 开始训练
    for epoch in range(epochs):
        scheduler.step()        #在每轮epoch之前更新学习率
        train(...)
        veritf(...)
    

    等间隔调整学习率 StepLR
    torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma=0.1, last_epoch=-1)
    每训练step_size个epoch,学习率调整为lr=lr*gamma.
    参数:
    optimizer: 神经网络训练中使用的优化器,如optimizer=torch.optim.SGD(…)
    step_size(int): 学习率下降间隔数,单位是epoch,而不是iteration.
    gamma(float): 学习率调整倍数,默认为0.1
    last_epoch(int): 上一个epoch数,这个变量用来指示学习率是否需要调整。当last_epoch符合设定的间隔时,就会对学习率进行调整;当为-1时,学习率设置为初始值。
    学习率变化如下图所示:
    在这里插入图片描述

    当然调整学习率的方式还有很多:
    多间隔调整学习率 MultiStepLR
    指数衰减调整学习率 ExponentialLR
    余弦退火函数调整学习率:
    根据指标调整学习率 ReduceLROnPlateau
    自定义调整学习率 LambdaLR

    网上都可以查到,这里就不一一列举了。

    欢迎留言讨论~ ^ _ ^
    To the_little_boy:

    # 前面省略了一部分代码,下面的代码仅供代码格式参考:
    args = parser.parse_args()
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    best_acc = 0  
    start_epoch = 0  
    
    # Data
    print('==> Preparing data..')
    transform_train = transforms.Compose([
        transforms.RandomCrop(32, padding=4),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
    ])
    
    transform_test = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
    ])
    
    dict_datasets={'CIFAR10':torchvision.datasets.CIFAR10, 'CIFAR100':torchvision.datasets.CIFAR100}
    
    trainset = dict_datasets[args.datasets](
        root='./data', train=True, download=True, transform=transform_train)
    trainloader = torch.utils.data.DataLoader(
        trainset, batch_size=args.batchsize, shuffle=True, num_workers=0)
    
    testset = dict_datasets[args.datasets](
        root='./data', train=False, download=True, transform=transform_test)
    testloader = torch.utils.data.DataLoader(
        testset, batch_size=args.batchsize_test, shuffle=False, num_workers=0)
    
    global_x.plot_lr=[]
    best_acc=0
    # Model
    print('==> Building model..')
    net = dict_model[args.model]
    
    net = net.to(device)
    if device == 'cuda':
        net = torch.nn.DataParallel(net)
        cudnn.benchmark = True
        
    criterion = nn.CrossEntropyLoss()
    #####################################################
    optimizer = optim.SGD(net.parameters(), lr=args.lr,
                            momentum=0.8, weight_decay=5e-4)
    
    scheduler = lr_scheduler.Warmup_lineardecay(optimizer, T_max=args.epochs, improved=args.improved)  
    ##################################################
    # Training
    train_Acc=np.array([])
    train_Loss=np.array([])
    def train(epoch):
        global train_Acc
        global train_Loss
        
        print('\nEpoch: %d' % epoch)
        net.train()
        train_loss = 0
        correct = 0
        total = 0
            
        for batch_idx, (inputs, targets) in enumerate(trainloader):
            inputs, targets = inputs.to(device), targets.to(device)
            optimizer.zero_grad()
            outputs = net(inputs)
            loss = criterion(outputs, targets)
            loss.backward()
            ##################梯度更新
            optimizer.step()
            ##################
            train_loss += loss.item()
            _, predicted = outputs.max(1)
            total += targets.size(0)
            correct += predicted.eq(targets).sum().item()
            progress_bar(batch_idx, len(trainloader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)'
                            % (train_loss/(batch_idx+1), 100.*correct/total, correct, total))
                            
        train_Acc=np.append(train_Acc,100.*correct/total)
        train_Loss=np.append(train_Loss,train_loss/(batch_idx+1))
        if not os.path.exists(args.model):
            os.mkdir(args.model)
        np.savetxt(args.model+'/result_of_train_acc.txt',train_Acc,fmt='%f')
        np.savetxt(args.model+'/result_of_train_loss.txt',train_Loss,fmt='%f')
    
    test_Acc=np.array([])
    test_Loss=np.array([])
    def test(epoch):
        global test_Acc
        global test_Loss
        global best_acc
        net.eval()
        test_loss = 0
        correct = 0
        total = 0
        with torch.no_grad():
                DATA_predict=np.empty([0,10])
                DATA_predict_index=np.empty([0,1])
                for batch_idx, (inputs, targets) in enumerate(testloader):
                    inputs, targets = inputs.to(device), targets.to(device)
                    outputs = net(inputs)
                    loss = criterion(outputs, targets)
                    test_loss += loss.item()
                    _, predicted = outputs.max(1)
                    total += targets.size(0)
                    correct += predicted.eq(targets).sum().item()
                    DATA_predict=np.append(DATA_predict,outputs.cpu(),axis=0)
                    DATA_predict_index=np.append(DATA_predict_index,targets.view(-1,1).cpu(),axis=0)
                    progress_bar(batch_idx, len(testloader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)'
                                % (test_loss/(batch_idx+1), 100.*correct/total, correct, total))
        test_Acc=np.append(test_Acc,100.*correct/total)
        global_x.reference_acc = correct/total
        test_Loss=np.append(test_Loss,test_loss/(batch_idx+1))
        np.savetxt(args.model+'/result_of_test_acc.txt',test_Acc,fmt='%f')
        np.savetxt(args.model+'/result_of_test_loss.txt',test_Loss,fmt='%f')
    
        # Save checkpoint.
        acc = 100.*correct/total
        if acc > best_acc:
                np.savetxt(args.model+'_DATA_predict.txt',DATA_predict,fmt='%f')
                np.savetxt(args.model+'_DATA_predict_index.txt',DATA_predict_index,fmt='%d')
                print('Saving..')
                state = {
                    'net': net.state_dict(),
                    'acc': acc,
                    'epoch': epoch,
                }
                if not os.path.isdir('checkpoint'):
                    os.mkdir('checkpoint')
                torch.save(state, './checkpoint/ckpt.pth')
                best_acc = acc
    
    for epoch in range(start_epoch, start_epoch+args.epochs):
            train(epoch)
            test(epoch)
            ################学习率更新,每轮更新一次,有些学习率的更新是每次迭代更新一次,注意区分,如果是每次迭代更新一次,可以把这一行放在梯度更新的下一行
            scheduler.step()
    		###################
    
    展开全文
  • 损失函数一直在下降,为什么识别上不去。 1.最常见的原因:过拟合 过拟合值得单独开个章节。主要包括 1.数据量小,网络复杂 2.learning rate 比较高,又没有设置任何防止过拟合的机制 解决方法主要包括 1....

    损失函数一直在下降,为什么识别率上不去。

    ----------------2021-01-08更新-----------------------

    0.学习率设置太高,一个epoch直接收敛,所以损失不会下降

    比如学利率一开始设置为1,因为下降太快,那么很有可能在一个epoch旧完全收敛。所以看到的validation数值并不下降,第一个epoch就已经处于谷底了。所以如果使用的是系统默认的学习率,最好检查下默认值是什么。

     

    -------------------旧---------------------------------------

    1.最常见的原因:过拟合

    过拟合值得单独开个章节。主要包括

    1.数据量小,网络复杂

    2.learning rate 比较高,又没有设置任何防止过拟合的机制

    解决方法主要包括

    1.简化模型,利用现有深度学习手段增加数据(翻转,平移,随机裁剪,imgaug)

    2.利用 dropout层

    3.利用正则化

    2.你犯了错误:没有把数据规格化

    图片的话,img/255是肯定的

    3.你犯了错误:没有在分验证集之前打乱数据

    因为validation_split操作不会为你shuffle数据,所以如果你的数据前一半标签全是1 ,后一半全是0,validation=0.5。恭喜你,你压根也分不对,你的validation准确率会一直为0.因为你拿所有的正样本训练,却想判断负样本。

    4.你犯了错误,数据和标签没有对上

    有可能再读取自定义的数据库的时候出现问题,导致数据与标注不对应。比如第一张图片用第十张的标注

    5.你的训练数据太少,validation数据太多,类别也太多

    比如4000张训练,1000张validation,300类,这显然就是不合理的。

    遇到这种情况,建议:

        1.使用别的大的数据集预训练

        2.使用DATA augment

        3.可以考虑迁移学习

     

    6.最好使用预训练的权重

    大多数流行的backone比如resnet都有再imagenet数据集上与训练过,那么使用这种权重,比起随即重新训练,显然要可靠不少注意调整学习率。

    7.网络结构有问题

    可以通过使用现在流行的网络(resnet,unet等)替入你的代码,如果结果没有问题,你的结果有问题那么肯定就是你网络结构出问题了。那么可以通过逐层注释掉排查究竟哪里出了问题

    7.1 网络最后一层没有使用正确的激活函数

    比如多类的应该使用softmax

    8.relu后面是softmax

    有一些说法是relu由于对于很大的数值直接复制,所以会对softmax产生不好的影响,从而输出不好的结果。所以可以使用tanh代替relu。

    9.batch normalization需要batch size至少16张

    https://mp.csdn.net/postedit/89456400

    由于做dense prediction图片通常比较大。所以一个batch一般都只有1-2张图片,不建议使用 BN。

    因为BN一般是16张图片以上一起跑。所以吧,如果是BN,那么请用多GPU,16以上的batch size。s

    另外keras TF1.x可能会出问题,https://github.com/keras-team/keras/pull/9965

    10.你犯了错误,你可能设置了一些参数是不可训练的

    在训练语句之前,检查以下你的trainable参数,是否设置了一些参数是不可训练的。这还可能导致你的输出只能是一个值,比如永远预测为标注0,因为你只有一点点的参数,而这并不是一个模型(比如只有100个参数是可以训练的,太简单了,无法模拟)。

     

    11.附送一个调参论文

    Bag of Tricks for Image Classification with Convolutional Neural Networks

    https://arxiv.org/abs/1812.01187

    NLP 独有错误 

    最傻的错误,比如train和val使用了不一样的字典,那效果能好才怪了。。。。

    展开全文
  • 有没有小伙伴遇到过用keras的InceptionV3、ResNet50等含有BN层的模型做迁移学习训练验证集结果相差很大的问题,例如下面这样: Epoch 1/20 1500/1500 [==============================] - 24s...
  • 查到的资料: 先留着,以后出问题还可以再回过来看 ... 自己的解决办法: 1、emmm,数据太杂了,一个标签里有很多有其他特征的图片,删掉就好了;???? 2、数据没有充分打乱。 ...
  • 问题1描述:迁移学习用resnet50做分类,验证集上的准确率一直是一个大问题,有时候稳定在一个低的准确率上上不去,我的一次是一直在75%上下波动。 问题2描述:resnet50迁移学习,最终训练上的准确率一直在攀升,...
  • 从一般角度来讲上,因为验证集与训练一模一样,所以fit表现的准确率或loss在验证集与训练上也应该一样。但是,训练上的准确率远远大于验证集上的,由此产生疑惑。 后来,我在翻找TensorFlow2 的API时,发现了...
  • ![图片说明](https://img-ask.csdn.net/upload/201904/10/1554868022_688030.png)!... tensorflow用CNN做短文本二分类,训练上的acc=0.95+,验证集上的acc=0.7+,请问有什么方法可以提高在验证集上的准确度吗?
  • 今天在测试模型时发现一个问题,keras训练模型,训练集准确率很高,测试集准确率很低,因此记录一下希望能帮助大家也避坑: 首先keras本身不同的版本都有些不同的或大或小的bug,包括之前也困扰过我的BN层问题(相信...
  • 这个情况在实际项目中其实挺常见的,...考虑下面这个例子:对于一个有4条数据的数据,它的真实label为[0, 1, 1, 1]。现在考虑两个不同的模型A,B。假设Model A预测的结果为: [0.5, 0.9, 0.9, 0.5], Model B预测的...
  • ![图片说明](https://img-ask.csdn.net/upload/202005/07/1588828638_841554.png)
  • 我们使用Tensorflow训练二元分类图像数据 700 images ,其中每个图像都是 256*256*1 ,数据平均分成两个类 . 我们稍微更改了 Tensorflow 上的 Cifar10 模型,我们的模型代码如下所示 .# conv1with tf.variable_...
  • Tensorflow2.0训练损失值降低,但测试正确基本不变的情况问题描述解决方法修改参数检查模型loss计算方法数据标签权重初始值 问题描述 对于一个架构,在识别mnist手写数字精度较高的情况下,更换其他的数据,却...
  • 网络输出垃圾,没有学习到任何东西Loss和accuracy都不改变,并且很低查看数据标签与数据是否对应查看验证集和测试是否进行数据预处理,包括归一化均值化查看loss损失函数是否选择正确,是否与标签格式相对应查看...
  • # 只要库中有就可以使用 使用预训练的ResNet50模型 covn_base = tf.keras.applications.ResNet50(weights='imagenet', include_top = False, input_shape=(im_height,im_width,3), layers=tf.keras.layers) ...
  • 我对一份数据构建了一个两层的baseline和一个深层的网络,两份模型在验证集上的表现是相同的acc 67左右,但是在测试上两层的网络acc 37,后面这个深层的63,为什么会这样? 同样的训练验证集和测试
  • 4、一次训练任务,精度上升非常快,出现精度高(iou 0.5),验证集精度低(1e-12),由于dataset的filelist[index]在测试的时候加了一个编号,写为filelist[0],导致对第一张一直训练,搞到凌晨三点没找到原因,...
  • 解决卷积神经网络测试正确

    千次阅读 2020-10-05 17:14:04
    在运用卷积神经网络进行图像识别的过程中,将数据分为训练验证集,首先进行模型的训练,最终模型在训练验证集上的正确均达到0.999,将训练好的模型保存到本地,测试过程中直接读取本地模型对视频帧进行...
  • 可以判定问题的原因来自两方面,一方面是模型过拟合,另一方面是训练和测试机的数据域不同。 一、问题定位: 至于问题的定位排查,建议按照先易后难的角度,也就是先排查训练和测试是否存在数据域的不同,再...
  • 验证集精确度和损失同时上升

    万次阅读 2019-07-03 11:19:25
    下图中val_acc,val_loss分别表示验证集精确度和损失;train_acc,train_loss分别表示训练精确度和损失。 验证集精确度一直上升,但是损失在第六个epoch后也开始上升,如何解释? 分析 在N标签分类任务中,输出是...
  • 1.没分验证集,直接把测试当作validation_data放进去,结果测试集准确率每个epoch准确率一直在0.3上,最后发现其真实准确率在0.6上 解决:把标签独热一下 2.每个epoch的最后一个batch的训练拟合准确率、训练...
  • 学习设置太高,一个epoch直接收敛,所以损失不会下降。又没有设置防止过拟合的比如学利率一开始设置为1,因为下降太快,那么很有可能在一个epoch旧完全收敛。所以看到的validation数值并不下降,第一个epoch就已经...
  • 新人一枚,想用CNN和LSTM分别实现一些垃圾邮件分类,CNN的效果不错,但是在用LSTM的时候,训练过程中loss是不断降低的,但是准确率始终只有0.5左右,测试代码跟cnn的一样,应该没有问题,我是只取了LSTM最后一步的...
  • fine-tuning的配置,除了指定文件路径外,可以调整学习为万分之一到十万分之一之间 fine-tuning中train.sh看是哪个模型保存了,要在predict.sh中引用 如果运行结果多次不变,就删除eval_output中的模型,重新跑...
  • 问题keras使用预训练模型vgg16分类,损失和准确不变。细节:使用keras训练一个两类数据,正负比例1:3,在vgg16后添加了几个全链接并初始化了。并且对所有层都允许训练。但是准确度一直是0.75.数据预先处理已经...
  • 准确率Accuracy与损失函数Loss的关系

    万次阅读 多人点赞 2020-03-06 17:32:31
    在进行一项分类任务训练时,观察到验证集上的accuracy增加的同时,loss也在增加,因此产生了一些疑惑,对accuracy和loss之间的关系进行探索。 定义 在理解他们的关系之前,先来回顾一下什么是交叉熵损失和准确率。...
  • 最近做实验(分类问题)的过程中发现,随着训练的平均交叉熵损失(Average Cross Entropy,ACE)降低,验证集ACE升高时,分类模型的准确率(Accuracy,ACC)也会出现升高的情况。 在栈溢出上也看到了同样类似的...
  • tensorflow官方文档有一个例子可以对mnist数据做分析,对于刚入门者,可以通过简单的模型达到92%的准确率。 以下代码分析是对应所做的分析,请看对应的中文注释 #!/usr/bin/env python # encoding: utf-

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,845
精华内容 8,738
关键字:

验证集准确率不变