def __init__(self,
gate=True,
size_arg="small",
dropout=False,
n_classes=2):
super(MIL_Attention_fc, self).__init__()
self.size_dict = {"small": [1024, 512, 256], "big": [1024, 512, 384]}
size = self.size_dict[size_arg]
fc = [nn.Linear(size[0], size[1]), nn.ReLU()]
if dropout:
fc.append(nn.Dropout(0.25))
if gate:
attention_net = Attn_Net_Gated(L=size[1],
D=size[2],
dropout=dropout,
n_classes=1)
else:
attention_net = Attn_Net(L=size[1],
D=size[2],
dropout=dropout,
n_classes=1)
fc.append(attention_net)
self.attention_net = nn.Sequential(*fc)
self.classifier = nn.Linear(size[1], n_classes)
initialize_weights(self)
def __init__(self,
device,
num_actions,
num_particles,
state_size=3,
noise_size=10):
# device: 'cpu' or 'gpu';
# state_size: the length of input state, default=3
# noise_size: the number of sampled noise, default=10
# num_action: the number of actions
# num_particles: the number of output particles
super(Generator, self).__init__()
self.state_size = state_size
self.noise_size = noise_size
self.num_actions = num_actions
self.num_particles = num_particles
self.device = device
self.embed_layer_state = nn.Linear(self.state_size, 256)
self.embed_layer_noise = nn.Linear(self.noise_size, 256)
# self.common_layer1 = nn.Linear(256, 256)
# self.common_layer2 = nn.Linear(256, 256)
self.common_layer = nn.Linear(256, 256)
self.value_layer1 = nn.Linear(256, 128)
self.value_layer2 = nn.Linear(128, num_particles)
# self.value_layer = nn.Linear(256, num_particles)
self.advantage_layer1 = nn.Linear(256, 128)
self.advantage_layer2 = nn.Linear(128, num_actions)
# self.advantage_layer = nn.Linear(256, num_actions)
initialize_weights(self)
def __init__(self, input_h_w=28, latent_v=62):
super(_G, self).__init__()
self.input_height = input_h_w
self.input_width = input_h_w
self.input_dim = latent_v
self.output_dim = 1
self.fc = nn.Sequential(
nn.Linear(self.input_dim, 1024),
nn.BatchNorm1d(1024),
nn.ReLU(),
nn.Linear(1024, 128 * (self.input_height // 4) *
(self.input_width // 4)),
nn.BatchNorm1d(128 * (self.input_height // 4) *
(self.input_width // 4)),
nn.ReLU(),
)
self.deconv = nn.Sequential(
nn.ConvTranspose2d(128, 64, 4, 2, 1),
nn.BatchNorm2d(64),
nn.ReLU(),
nn.ConvTranspose2d(64, self.output_dim, 4, 2, 1),
nn.Sigmoid(),
)
utils.initialize_weights(self)
def __init__(self, input_dim: int=2227, fusion='tensor',
gate=True, gate_path=True, gate_omic=True, dropout=True,
model_size_wsi: str='small', model_size_omic: str='small', n_classes=4):
super(MM_MIL_Attention_fc, self).__init__()
self.fusion = fusion
self.n_classes = n_classes
self.size_dict_WSI = {"small": [1024, 512, 256], "big": [1024, 512, 384]}
self.size_dict_omic = {'small': [256, 256], 'big': [1024, 1024, 1024, 256]}
### WSI Attention MIL Construction
size = self.size_dict_WSI[model_size_wsi]
fc = [nn.Linear(size[0], size[1]), nn.ReLU()]
fc.append(nn.Dropout(0.25))
if gate: attention_net = Attn_Net_Gated(L = size[1], D = size[2], dropout = dropout, n_classes = 1)
else: attention_net = Attn_Net(L = size[1], D = size[2], dropout = dropout, n_classes = 1)
fc.append(attention_net)
self.attention_net = nn.Sequential(*fc)
### Constructing Genomic SNN
hidden = self.size_dict_omic[model_size_omic]
fc_omic = [SNN_Block(dim1=input_dim, dim2=hidden[0])]
for i, _ in enumerate(hidden[1:]):
fc_omic.append(SNN_Block(dim1=hidden[i], dim2=hidden[i+1], dropout=0.25))
self.fc_omic = nn.Sequential(*fc_omic)
### Multimodal Fusion Construction
if self.fusion == 'tensor':
self.mm = BilinearFusion(skip=True, gate1=gate_path, gate2=gate_omic, dim1=512, dim2=256, scale_dim1=16, scale_dim2=8)
self.classifier = nn.Linear(512, n_classes)
initialize_weights(self)
def __init__(self, num_particles):
super(Discriminator, self).__init__()
self.num_inputs = num_particles
self.fc1 = nn.Linear(self.num_inputs, 256)
self.fc2 = nn.Linear(256, 256)
self.fc3 = nn.Linear(256, 1)
initialize_weights(self)
def __init__(self, num_samples, num_outputs):
super(Discriminator, self).__init__()
self.num_inputs = num_samples
self.num_outputs = num_outputs
self.fc1 = nn.Linear(self.num_inputs, 512)
self.fc2 = nn.Linear(512, 512)
self.fc3 = nn.Linear(512, self.num_outputs)
initialize_weights(self)
def __init__(self,
gate=True,
size_arg="A",
dropout=False,
n_classes=2,
top_k=1):
super(MIL_fc, self).__init__()
assert n_classes == 2
self.size_dict = {"A": [1024, 512], "B": [512, 512]}
size = self.size_dict[size_arg]
fc = [nn.Linear(size[0], size[1]), nn.ReLU()]
if dropout:
fc.append(nn.Dropout(0.25))
fc.append(nn.Linear(size[1], n_classes))
self.classifier = nn.Sequential(*fc)
initialize_weights(self)
self.top_k = top_k
def __init__(self, gate=True, size_arg="A", dropout=False, n_classes=2):
super(MIL_Attention_Softmax, self).__init__()
self.size_dict = {"A": [1024, 256], "B": [1024, 512]}
size = self.size_dict[size_arg]
if gate:
self.attention_net = Attn_Net_Gated(L=size[0],
D=size[1],
dropout=dropout,
n_classes=1)
else:
self.attention_net = Attn_Net(L=size[0],
D=size[1],
dropout=dropout,
n_classes=1)
self.classifier = nn.Linear(size[0], n_classes)
initialize_weights(self)
def __init__(self,
gate=True,
size_arg="A",
dropout=False,
n_classes=2,
top_k=1):
super(MIL_fc_mc, self).__init__()
assert n_classes > 2
self.size_dict = {"A": [1024, 512], "B": [512, 512]}
size = self.size_dict[size_arg]
fc = [nn.Linear(size[0], size[1]), nn.ReLU()]
if dropout:
fc.append(nn.Dropout(0.25))
self.fc = nn.Sequential(*fc)
self.classifiers = nn.ModuleList(
[nn.Linear(size[1], 1) for i in range(n_classes)])
initialize_weights(self)
self.top_k = top_k
self.n_classes = n_classes
assert self.top_k == 1
def __init__(self, state_size, num_actions, num_samples, embedding_dim):
super(Generator, self).__init__()
self.state_size = state_size # input_shape --> num_channels * hight * width
self.num_actions = num_actions
self.num_samples = num_samples
self.embedding_dim = embedding_dim
# self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
self.device = torch.device('cuda')
self.embed_layer_1 = nn.Linear(self.state_size, self.embedding_dim)
# self.embed_layer_drop_1 = nn.Dropout(0.5)
self.embed_layer_2 = nn.Linear(self.embedding_dim, self.embedding_dim)
# self.embed_layer_drop_2 = nn.Dropout(0.5)
self.fc1 = nn.Linear(self.embedding_dim, 256)
self.drop1 = nn.Dropout(0.5)
self.fc2 = nn.Linear(256, 128)
self.drop2 = nn.Dropout(0.5)
self.fc3 = nn.Linear(128, self.num_actions)
initialize_weights(self)
def __init__(self,
gate=True,
size_arg="small",
dropout=False,
k_sample=8,
n_classes=2,
instance_loss_fn=nn.CrossEntropyLoss(),
subtyping=False):
nn.Module.__init__(self)
self.size_dict = {"small": [1024, 512, 256], "big": [1024, 512, 384]}
size = self.size_dict[size_arg]
fc = [nn.Linear(size[0], size[1]), nn.ReLU()]
if dropout:
fc.append(nn.Dropout(0.25))
if gate:
attention_net = Attn_Net_Gated(L=size[1],
D=size[2],
dropout=dropout,
n_classes=n_classes)
else:
attention_net = Attn_Net(L=size[1],
D=size[2],
dropout=dropout,
n_classes=n_classes)
fc.append(attention_net)
self.attention_net = nn.Sequential(*fc)
bag_classifiers = [
nn.Linear(size[1], 1) for i in range(n_classes)
] #use an indepdent linear layer to predict each class
self.classifiers = nn.ModuleList(bag_classifiers)
instance_classifiers = [
nn.Linear(size[1], 2) for i in range(n_classes)
]
self.instance_classifiers = nn.ModuleList(instance_classifiers)
self.k_sample = k_sample
self.instance_loss_fn = instance_loss_fn
self.n_classes = n_classes
self.subtyping = subtyping
initialize_weights(self)
def __init__(self,
cfg='yolov5s.yaml',
ch=3,
nc=None): # model, input channels, number of classes
super(Model, self).__init__()
if isinstance(cfg, dict):
self.yaml = cfg # model dict
else: # is *.yaml
import yaml # for torch hub
self.yaml_file = Path(cfg).name
with open(cfg) as f:
self.yaml = yaml.load(f, Loader=yaml.FullLoader) # model dict
# Define model
if nc and nc != self.yaml['nc']:
print('Overriding %s nc=%g with nc=%g' %
(cfg, self.yaml['nc'], nc))
self.yaml['nc'] = nc # override yaml value
self.model, self.save = parse_model(deepcopy(self.yaml),
ch=[ch]) # model, savelist, ch_out
# print([x.shape for x in self.forward(torch.zeros(1, ch, 64, 64))])
# Build strides, anchors
m = self.model[-1] # Detect()
if isinstance(m, Detect):
s = 128 # 2x min stride
m.stride = torch.tensor([
s / x.shape[-2] for x in self.forward(torch.zeros(1, ch, s, s))
]) # forward
m.anchors /= m.stride.view(-1, 1, 1)
check_anchor_order(m)
self.stride = m.stride
self._initialize_biases() # only run once
# print('Strides: %s' % m.stride.tolist())
# Init weights, biases
initialize_weights(self)
self.info()
print('')
def __init__(self, gate=True, size_arg="A", dropout=False):
super(CPC_MIL_Attention, self).__init__()
self.size_dict = {"A": [1024, 256], "B": [1024, 512]}
size = self.size_dict[size_arg]
if gate:
self.attention_net = Attn_Net_Gated(L=size[0],
D=size[1],
dropout=dropout,
n_classes=1)
else:
self.attention_net = Attn_Net(L=size[0],
D=size[1],
dropout=dropout,
n_classes=1)
self.classifier = nn.Sequential(nn.Linear(size[0], 1), nn.Sigmoid())
initialize_weights(
self
) # initialize weights before loading the weights for feature network
def __init__(self, input_h_w=28):
super(_D, self).__init__()
self.input_height = input_h_w
self.input_width = input_h_w
self.input_dim = 1
self.output_dim = 1
self.conv = nn.Sequential(
nn.Conv2d(self.input_dim, 64, 4, 2, 1),
nn.LeakyReLU(0.2),
nn.Conv2d(64, 128, 4, 2, 1),
nn.BatchNorm2d(128),
nn.LeakyReLU(0.2),
)
self.fc = nn.Sequential(
nn.Linear(128 * (self.input_height // 4) * (self.input_width // 4),
1024),
nn.BatchNorm1d(1024),
nn.LeakyReLU(0.2),
nn.Linear(1024, self.output_dim),
nn.Sigmoid(),
)
utils.initialize_weights(self)
