Deep Multi-instance Learning with Dynamic Pooling的复现与思考

准确率是0.98

假设:正包中可能不止一个正示例，训练网络时网络能充分考虑这些示例就会进一步提升准确率。

本文就是通过动态池化去提升准确率。

训练的体会:如果神经网络层多的话学习率小模型的loss变化的较慢。

用迭代的方式生成b其实就是让最重要的向量发挥尽量大的作用，越迭代重要的向量的b越大。

s表示负包的范式比较小接近于0，正包的范式比较大。

复现代码:

from enum import auto
from scipy.io import loadmat
import numpy as np
import torch
import torch.utils.data as data_utils
from torch import nn
import torch.optim as optim

m = loadmat(r"musk_2_original.mat")
daaa=m.keys()
from torch import nn
network=nn.Sequential(nn.Linear(166,256),nn.Sigmoid(),nn.Linear(256,128),nn.Sigmoid(),nn.Linear(128,64),nn.Sigmoid())
#network=nn.Sequential(nn.BatchNorm1d(166),nn.Linear(166,2),nn.Softmax(dim=1))

optimizer = optim.Adam(network.parameters(), lr=0.004)
m1 = loadmat(r"musk_1_original.mat")
val_bag=[]
val_bag_lable=[]
train_bag=[]
train_bag_lable=[]
for i in m1[‘pos_bag’]:
for j in i:
val_bag.append(j.T)
val_bag_lable.append(1)
for i in m1[‘neg_bag’]:
for j in i:
val_bag.append(j.T)
val_bag_lable.append(0)
for i in m[‘pos_bag’]:
for j in i:
train_bag.append(j.T)
train_bag_lable.append(1)
for i in m[‘neg_bag’]:
for j in i:
train_bag.append(j.T)
train_bag_lable.append(0)
t=0.1
bo=0.5
for epoch in range(500000):
r=0
e=0
er=0
acc=0
sum=0
network.train()
lo=0
train_ac=0
test_ac=0
train_ac1=0
train_ac0=0
val_ac1=0
val_ac0=0
for i in range(len(train_bag)):
y=network(torch.Tensor(train_bag[i]))
b=torch.zeros((len(y),1))
sof=nn.Softmax(dim=0)
y1=y*sof(b)
y1=torch.sum(y1,dim=0)
s=y1/torch.norm(y1)*torch.norm(y1)**2/(1+torch.norm(y1)**2)

    for j in range(3):
        b1=sof(torch.matmul(y,s.T))
        b1=torch.reshape(b1,(-1,1))
        b=b+b1
        c=sof(b)
        y1=y*sof(b)
        y1=torch.sum(y1,dim=0)
        s=y1/torch.norm(y1)*torch.norm(y1)**2/(1+torch.norm(y1)**2)  
    #print(torch.norm(s))
    lo=lo+train_bag_lable[i]*(1-torch.norm(s))**2+(1-train_bag_lable[i])*(torch.norm(s))**2
    #if train_bag_lable[i]==0:
        #print(torch.norm(s))
    if torch.norm(s)>bo and train_bag_lable[i]==1:
        train_ac=train_ac+1
        train_ac1=train_ac1+1
    if torch.norm(s)<bo and train_bag_lable[i]==0:
        train_ac=train_ac+1
        train_ac0=train_ac0+1
optimizer.zero_grad()
lo.backward()
optimizer.step()




for i in range(len(val_bag)):
    y=network(torch.Tensor(val_bag[i]))
    b=torch.zeros((len(y),1))
    sof=nn.Softmax(dim=0)
    y1=y*sof(b)
    y1=torch.sum(y1,dim=0)
    s=y1/torch.norm(y1)*torch.norm(y1)**2/(1+torch.norm(y1)**2)
    for j in range(3):
        b1=sof(torch.matmul(y,s.T))
        b1=torch.reshape(b1,(-1,1))
        b=b+b1
        c=sof(b)
        y1=y*c
        y1=torch.sum(y1,dim=0)
        s=y1/torch.norm(y1)*torch.norm(y1)**2/(1+torch.norm(y1)**2)

    if torch.norm(s)>bo and val_bag_lable[i]==1:
        test_ac=test_ac+1
        val_ac1=val_ac1+1
    if torch.norm(s)<bo and val_bag_lable[i]==0:
        test_ac=test_ac+1
        val_ac0=val_ac0+1

print(epoch,lo,train_ac/len(train_bag),test_ac/len(val_bag),train_ac1,train_ac0,val_ac1,val_ac0)