pytorch構建雙模型

第一部分：構建"se_resnet152","DPN92()"雙模型

import numpy as np
from functools import partial
import torch
from torch import nn
import torch.nn.functional as F
from torch.optim import SGD,Adam
from torch.autograd import Variable
from torch.utils.data import Dataset,DataLoader

from torch.optim.optimizer import Optimizer

import torchvision
from torchvision import models
import pretrainedmodels
from pretrainedmodels.models import *
from torch import nn
from torchvision import transforms as T
import random



random.seed(2050)
np.random.seed(2050)
torch.manual_seed(2050)
torch.cuda.manual_seed_all(2050)

class FCViewer(nn.Module):
  def forward(self,x):
    return x.view(x.size(0),-1)

  
'''Dual Path Networks in PyTorch.'''
class Bottleneck(nn.Module):
  def __init__(self,last_planes,in_planes,out_planes,dense_depth,stride,first_layer):
    super(Bottleneck,self).__init__()
    self.out_planes = out_planes
    self.dense_depth = dense_depth

    self.conv1 = nn.Conv2d(last_planes,kernel_size=1,bias=False)
    self.bn1 = nn.BatchNorm2d(in_planes)
    self.conv2 = nn.Conv2d(in_planes,kernel_size=3,stride=stride,padding=1,groups=32,bias=False)
    self.bn2 = nn.BatchNorm2d(in_planes)
    self.conv3 = nn.Conv2d(in_planes,out_planes+dense_depth,bias=False)
    self.bn3 = nn.BatchNorm2d(out_planes+dense_depth)

    self.shortcut = nn.Sequential()
    if first_layer:
      self.shortcut = nn.Sequential(
        nn.Conv2d(last_planes,bias=False),nn.BatchNorm2d(out_planes+dense_depth)
      )

  def forward(self,x):
    out = F.relu(self.bn1(self.conv1(x)))
    out = F.relu(self.bn2(self.conv2(out)))
    out = self.bn3(self.conv3(out))
    x = self.shortcut(x)
    d = self.out_planes
    out = torch.cat([x[:,:d,:,:]+out[:,:],x[:,d:,out[:,:]],1)
    out = F.relu(out)
    return out


class DPN(nn.Module):
  def __init__(self,cfg):
    super(DPN,self).__init__()
    in_planes,out_planes = cfg['in_planes'],cfg['out_planes']
    num_blocks,dense_depth = cfg['num_blocks'],cfg['dense_depth']

    self.conv1 = nn.Conv2d(7,64,stride=1,bias=False)
    self.bn1 = nn.BatchNorm2d(64)
    self.last_planes = 64
    self.layer1 = self._make_layer(in_planes[0],out_planes[0],num_blocks[0],dense_depth[0],stride=1)
    self.layer2 = self._make_layer(in_planes[1],out_planes[1],num_blocks[1],dense_depth[1],stride=2)
    self.layer3 = self._make_layer(in_planes[2],out_planes[2],num_blocks[2],dense_depth[2],stride=2)
    self.layer4 = self._make_layer(in_planes[3],out_planes[3],num_blocks[3],dense_depth[3],stride=2)
    self.linear = nn.Linear(out_planes[3]+(num_blocks[3]+1)*dense_depth[3],64) 
    self.bn2 = nn.BatchNorm1d(64)
  def _make_layer(self,num_blocks,stride):
    strides = [stride] + [1]*(num_blocks-1)
    layers = []
    for i,stride in enumerate(strides):
      layers.append(Bottleneck(self.last_planes,i==0))
      self.last_planes = out_planes + (i+2) * dense_depth
    return nn.Sequential(*layers)

  def forward(self,x):
    out = F.relu(self.bn1(self.conv1(x)))
    out = self.layer1(out)
    out = self.layer2(out)
    out = self.layer3(out)
    out = self.layer4(out)
    out = F.avg_pool2d(out,4)
    out = out.view(out.size(0),-1)
    out = self.linear(out)
    out= F.relu(self.bn2(out))
    return out



def DPN26():
  cfg = {
    'in_planes': (96,192,384,768),'out_planes': (256,512,1024,2048),'num_blocks': (2,2,2),'dense_depth': (16,32,24,128)
  }
  return DPN(cfg)

def DPN92():
  cfg = {
    'in_planes': (96,'num_blocks': (3,4,20,3),128)
  }
  return DPN(cfg)
class MultiModalNet(nn.Module):
  def __init__(self,backbone1,backbone2,drop,pretrained=True):
    super().__init__()
    if pretrained:
      img_model = pretrainedmodels.__dict__[backbone1](num_classes=1000,pretrained='imagenet') #seresnext101
    else:
      img_model = pretrainedmodels.__dict__[backbone1](num_classes=1000,pretrained=None)
    
    self.visit_model=DPN26()
    
    self.img_encoder = list(img_model.children())[:-2]
    self.img_encoder.append(nn.AdaptiveAvgPool2d(1))
    
    self.img_encoder = nn.Sequential(*self.img_encoder)
    if drop > 0:
      self.img_fc = nn.Sequential(FCViewer(),nn.Dropout(drop),nn.Linear(img_model.last_linear.in_features,512),nn.BatchNorm1d(512))
                  
    else:
      self.img_fc = nn.Sequential(
        FCViewer(),nn.BatchNorm1d(img_model.last_linear.in_features),512))
    self.bn=nn.BatchNorm1d(576)
    self.cls = nn.Linear(576,9) 

  def forward(self,x_img,x_vis):
    x_img = self.img_encoder(x_img)
    x_img = self.img_fc(x_img)
    x_vis=self.visit_model(x_vis)
    x_cat = torch.cat((x_img,x_vis),1)
    x_cat = F.relu(self.bn(x_cat))
    x_cat = self.cls(x_cat)
    return x_cat

test_x = Variable(torch.zeros(64,7,26,24))
test_x1 = Variable(torch.zeros(64,3,224,224))
model=MultiModalNet("se_resnet152","DPN92()",0.1)
out=model(test_x1,test_x)
print(model._modules.keys())
print(model)

print(out.shape)

第二部分構建densenet201單模型

#encoding:utf-8
import torchvision.models as models
import torch
import pretrainedmodels
from torch import nn
from torch.autograd import Variable
#model = models.resnet18(pretrained=True)
#print(model)
#print(model._modules.keys())
#feature = torch.nn.Sequential(*list(model.children())[:-2])#模型的結構
#print(feature)
'''
class FCViewer(nn.Module):
  def forward(self,-1)
class M(nn.Module):
  def __init__(self,pretrained=True):
    super(M,self).__init__()
    if pretrained:
      img_model = pretrainedmodels.__dict__[backbone1](num_classes=1000,pretrained='imagenet') 
    else:
      img_model = pretrainedmodels.__dict__[backbone1](num_classes=1000,pretrained=None)
    
    self.img_encoder = list(img_model.children())[:-1]
    self.img_encoder.append(nn.AdaptiveAvgPool2d(1))
    self.img_encoder = nn.Sequential(*self.img_encoder)

    if drop > 0:
      self.img_fc = nn.Sequential(FCViewer(),236))
                  
    else:
      self.img_fc = nn.Sequential(
        FCViewer(),236)
      )

    self.cls = nn.Linear(236,x_img):
    x_img = self.img_encoder(x_img)
    x_img = self.img_fc(x_img)
    return x_img 

model1=M('densenet201',pretrained=True)
print(model1)
print(model1._modules.keys())
feature = torch.nn.Sequential(*list(model1.children())[:-2])#模型的結構
feature1 = torch.nn.Sequential(*list(model1.children())[:])
#print(feature)
#print(feature1)
test_x = Variable(torch.zeros(1,100,100))
out=feature(test_x)
print(out.shape)
'''
'''
import torch.nn.functional as F
class LenetNet(nn.Module):
  def __init__(self):
    super(LenetNet,self).__init__()
    self.conv1 = nn.Conv2d(7,6,5) 
    self.conv2 = nn.Conv2d(6,16,5) 
    self.fc1  = nn.Linear(144,120)
    self.fc2  = nn.Linear(120,84)
    self.fc3  = nn.Linear(84,10)
  def forward(self,x): 
    x = F.max_pool2d(F.relu(self.conv1(x)),(2,2)) 
    x = F.max_pool2d(F.relu(self.conv2(x)),2)
    x = x.view(x.size()[0],-1) 
    x = F.relu(self.fc1(x))
    x = F.relu(self.fc2(x))
    x = self.fc3(x)    
    return x

model1=LenetNet()
#print(model1)
#print(model1._modules.keys())
feature = torch.nn.Sequential(*list(model1.children())[:-3])#模型的結構
#feature1 = torch.nn.Sequential(*list(model1.children())[:])
print(feature)
#print(feature1)
test_x = Variable(torch.zeros(1,27,24))
out=model1(test_x)
print(out.shape)

class FCViewer(nn.Module):
  def forward(self,-1)
class M(nn.Module):
  def __init__(self):
    super(M,self).__init__()
    img_model =model1 
    self.img_encoder = list(img_model.children())[:-3]
    self.img_encoder.append(nn.AdaptiveAvgPool2d(1))
    self.img_encoder = nn.Sequential(*self.img_encoder)
    self.img_fc = nn.Sequential(FCViewer(),nn.Linear(16,236))
    self.cls = nn.Linear(236,x_img):
    x_img = self.img_encoder(x_img)
    x_img = self.img_fc(x_img)
    return x_img 

model2=M()

test_x = Variable(torch.zeros(1,24))
out=model2(test_x)
print(out.shape)

'''

以上這篇pytorch構建多模型例項就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支援我們。