Autoecoder实现的两种方式

autoencoder implement1

import torch
import torch.nn as nn
import torch.nn.functional as F 

### simple autoencoder
def init_weights(m):
    """ initialize weights of fully connected layer
    """
    if type(m) == nn.Linear:
        nn.init.xavier_uniform_(m.weight)
        m.bias.data.fill_(0.01)

# Encoder
class Encoder(nn.Module):
    def __init__(self, input_dim,hidden_size):
        super(Encoder, self).__init__()
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, hidden_size[0]),
            nn.ReLU(),
            nn.Linear(hidden_size[0],hidden_size[1]))
        self.encoder.apply(init_weights)
    def forward(self, x):
        x = self.encoder(x)
        return x
# Decoder
class Decoder(nn.Module):
    def __init__(self, input_dim,hidden_size):
        super(Decoder, self).__init__()
        self.decoder = nn.Sequential(
            nn.Linear(hidden_size[1], hidden_size[0]),
            nn.ReLU(),
            nn.Linear(hidden_size[0], input_dim),
            nn.ReLU())
        self.decoder.apply(init_weights)
    def forward(self, x):
        x = self.decoder(x)
        return x



# Autoencoder
class AutoEncoder(nn.Module):
    def __init__(self, input_dim,hidden_size=[64,32]):
        super(AutoEncoder, self).__init__()
        self.encoder = Encoder(input_dim,hidden_size)
        self.decoder = Decoder(input_dim,hidden_size)
    def forward_single(self, x):
        h = self.encoder(x)
        x = self.decoder(h)
        return h, x
    def forward(self,x1,x2,x3,x4):
        """
        x1:anchor
        x2:postive
        x3:negative
        x4:limits/adherence
        """
        output1,recons1 = self.forward_single(x1)
        output2,recons2 = self.forward_single(x2)
        output3,recons3 = self.forward_single(x3)
        output4,recons4 = self.forward_single(x4)
        return output1, output2, output3,output4,recons1,recons2,recons3,recons4

    def encodeBatch(self, X, batch_size=256):
        #需要注意的是encodeBatch和直接用encode会有一些微小的差异
        self.eval()    
        dataloader = torch.utils.data.DataLoader(
            X, batch_size=batch_size, pin_memory=False, shuffle=False)
        from tqdm import tqdm
        data_iterator = tqdm(dataloader, leave=False, unit="batch")
        features = []
        for batch in data_iterator:
            batch = batch.squeeze(1).view(batch.size(0), -1)
            output,_ = self.forward_single(batch)
            features.append(output.detach().cpu())  # move to the CPU to prevent out of memory on the GPU
        return torch.cat(features,dim=0)
    
hidden_size=[64,32]
torch.manual_seed(1)
model = AutoEncoder(input_dim=1000,hidden_size=hidden_size)
print(model)
print(model.encoder.encoder[0].weight) 

x = torch.randn(1,1000)
model.forward_single(x)

结果如下

autoencoder implement2

import torch
import torch.nn as nn

def buildNetwork(layers, type, activation=["relu"],last_act =False):
    print(layers)
    net = []
    if(last_act):
        for i in range(1, len(layers)):
            net.append(nn.Linear(layers[i-1], layers[i]))
            if activation=="relu":
                net.append(nn.ReLU())
            elif activation=="sigmoid":
                net.append(nn.Sigmoid())
            else:
                pass
        
    if(not last_act):
        for i in range(1, len(layers)-1):
            net.append(nn.Linear(layers[i-1], layers[i]))
            if activation=="relu":
                net.append(nn.ReLU())
            elif activation=="sigmoid":
                net.append(nn.Sigmoid())
            else:
                pass
        net.append(nn.Linear(layers[len(layers)-2],layers[len(layers)-1]))
    return nn.Sequential(*net)

### simple autoencoder
def init_weights(m):
    """ initialize weights of fully connected layer
    """
    if type(m) == nn.Linear:
        nn.init.xavier_uniform_(m.weight)
        m.bias.data.fill_(0.01)
        
# Autoencoder
class AutoEncoder2(nn.Module):
    def __init__(self, input_dim=1000, z_dim=32, encodeLayer=[64], decodeLayer=[64],activation="relu"):
        super(AutoEncoder2, self).__init__()
        self.encoder = buildNetwork([input_dim]+encodeLayer+[z_dim], type="encode", activation=activation,last_act=False)
        self.encoder.apply(init_weights)
        self.decoder = buildNetwork([z_dim]+decodeLayer+[input_dim], type="decode", activation=activation,last_act=True)
        self.decoder.apply(init_weights)
    def forward_single(self, x):
        h = self.encoder(x)
        x = self.decoder(h)
        return h, x
    def forward(self,x1,x2,x3,x4):
        """
        x1:anchor
        x2:postive
        x3:negative
        x4:limits/adherence
        """
        output1,recons1 = self.forward_single(x1)
        output2,recons2 = self.forward_single(x2)
        output3,recons3 = self.forward_single(x3)
        output4,recons4 = self.forward_single(x4)
        return output1, output2, output3,output4,recons1,recons2,recons3,recons4

    def encodeBatch(self, X, batch_size=256):
        #需要注意的是encodeBatch和直接用encode会有一些微小的差异
        self.eval()    
        dataloader = torch.utils.data.DataLoader(
            X, batch_size=batch_size, pin_memory=False, shuffle=False)
        from tqdm import tqdm
        data_iterator = tqdm(dataloader, leave=False, unit="batch")
        features = []
        for batch in data_iterator:
            batch = batch.squeeze(1).view(batch.size(0), -1)
            output,_ = self.forward_single(batch)
            features.append(output.detach().cpu())  # move to the CPU to prevent out of memory on the GPU
        return torch.cat(features,dim=0)

torch.manual_seed(1)
model = AutoEncoder2(input_dim=1000, z_dim=32,
             encodeLayer=[64], decodeLayer=[64]) ## not use noise
print(model)

print(model.encoder[0].weight) 
x = torch.randn(1,1000)
model.forward_single(x)

结果如下

第二种实现还有一个好处

buildNetwork是可以构造空网络的

空squential 网络

import torch
import torch.nn as nn

def buildNetwork(layers, type, activation=["relu"],last_act =False):
    print(layers)
    net = []
    if(last_act):
        for i in range(1, len(layers)):
            net.append(nn.Linear(layers[i-1], layers[i]))
            if activation=="relu":
                net.append(nn.ReLU())
            elif activation=="sigmoid":
                net.append(nn.Sigmoid())
            else:
                pass
        
    if(not last_act):
        for i in range(1, len(layers)-1):
            net.append(nn.Linear(layers[i-1], layers[i]))
            if activation=="relu":
                net.append(nn.ReLU())
            elif activation=="sigmoid":
                net.append(nn.Sigmoid())
            else:
                pass
        net.append(nn.Linear(layers[len(layers)-2],layers[len(layers)-1]))
    return nn.Sequential(*net)

### simple autoencoder
def init_weights(m):
    """ initialize weights of fully connected layer
    """
    if type(m) == nn.Linear:
        nn.init.xavier_uniform_(m.weight)
        m.bias.data.fill_(0.01)
        
# Autoencoder
class AutoEncoder2(nn.Module):
    def __init__(self, input_dim=1000, z_dim=32, encodeLayer=[64], decodeLayer=[64],activation="relu"):
        super(AutoEncoder2, self).__init__()
        self.encoder = buildNetwork([input_dim]+encodeLayer+[z_dim], type="encode", activation=activation,last_act=False)
        self.encoder.apply(init_weights)
        self.AAA = buildNetwork([z_dim], type="decode", activation=activation,last_act=True)
        self.decoder = buildNetwork([z_dim]+decodeLayer+[input_dim], type="decode", activation=activation,last_act=True)
        self.decoder.apply(init_weights)
    def forward_single(self, x):
        h = self.encoder(x)
        h = self.AAA(h)
        x = self.decoder(h)
        return h, x
    def forward(self,x1,x2,x3,x4):
        """
        x1:anchor
        x2:postive
        x3:negative
        x4:limits/adherence
        """
        output1,recons1 = self.forward_single(x1)
        output2,recons2 = self.forward_single(x2)
        output3,recons3 = self.forward_single(x3)
        output4,recons4 = self.forward_single(x4)
        return output1, output2, output3,output4,recons1,recons2,recons3,recons4

    def encodeBatch(self, X, batch_size=256):
        #需要注意的是encodeBatch和直接用encode会有一些微小的差异
        self.eval()    
        dataloader = torch.utils.data.DataLoader(
            X, batch_size=batch_size, pin_memory=False, shuffle=False)
        from tqdm import tqdm
        data_iterator = tqdm(dataloader, leave=False, unit="batch")
        features = []
        for batch in data_iterator:
            batch = batch.squeeze(1).view(batch.size(0), -1)
            output,_ = self.forward_single(batch)
            features.append(output.detach().cpu())  # move to the CPU to prevent out of memory on the GPU
        return torch.cat(features,dim=0)

torch.manual_seed(1)
model = AutoEncoder2(input_dim=1000, z_dim=32,
             encodeLayer=[64], decodeLayer=[]) ## not use noise
print(model)

print(model.encoder[0].weight) 
x = torch.randn(1,1000)
model.forward_single(x)

结果如下

对比版本

import torch
import torch.nn as nn

def buildNetwork(layers, type, activation=["relu"],last_act =False):
    print(layers)
    net = []
    if(last_act):
        for i in range(1, len(layers)):
            net.append(nn.Linear(layers[i-1], layers[i]))
            if activation=="relu":
                net.append(nn.ReLU())
            elif activation=="sigmoid":
                net.append(nn.Sigmoid())
            else:
                pass
        
    if(not last_act):
        for i in range(1, len(layers)-1):
            net.append(nn.Linear(layers[i-1], layers[i]))
            if activation=="relu":
                net.append(nn.ReLU())
            elif activation=="sigmoid":
                net.append(nn.Sigmoid())
            else:
                pass
        net.append(nn.Linear(layers[len(layers)-2],layers[len(layers)-1]))
    return nn.Sequential(*net)

### simple autoencoder
def init_weights(m):
    """ initialize weights of fully connected layer
    """
    if type(m) == nn.Linear:
        nn.init.xavier_uniform_(m.weight)
        m.bias.data.fill_(0.01)
        
# Autoencoder
class AutoEncoder2(nn.Module):
    def __init__(self, input_dim=1000, z_dim=32, encodeLayer=[64], decodeLayer=[64],activation="relu"):
        super(AutoEncoder2, self).__init__()
        self.encoder = buildNetwork([input_dim]+encodeLayer+[z_dim], type="encode", activation=activation,last_act=False)
        self.encoder.apply(init_weights)
        #self.AAA = buildNetwork([z_dim], type="decode", activation=activation,last_act=True)
        self.decoder = buildNetwork([z_dim]+decodeLayer+[input_dim], type="decode", activation=activation,last_act=True)
        self.decoder.apply(init_weights)
    def forward_single(self, x):
        h = self.encoder(x)
        #h = self.AAA(h)
        x = self.decoder(h)
        return h, x
    def forward(self,x1,x2,x3,x4):
        """
        x1:anchor
        x2:postive
        x3:negative
        x4:limits/adherence
        """
        output1,recons1 = self.forward_single(x1)
        output2,recons2 = self.forward_single(x2)
        output3,recons3 = self.forward_single(x3)
        output4,recons4 = self.forward_single(x4)
        return output1, output2, output3,output4,recons1,recons2,recons3,recons4

    def encodeBatch(self, X, batch_size=256):
        #需要注意的是encodeBatch和直接用encode会有一些微小的差异
        self.eval()    
        dataloader = torch.utils.data.DataLoader(
            X, batch_size=batch_size, pin_memory=False, shuffle=False)
        from tqdm import tqdm
        data_iterator = tqdm(dataloader, leave=False, unit="batch")
        features = []
        for batch in data_iterator:
            batch = batch.squeeze(1).view(batch.size(0), -1)
            output,_ = self.forward_single(batch)
            features.append(output.detach().cpu())  # move to the CPU to prevent out of memory on the GPU
        return torch.cat(features,dim=0)

torch.manual_seed(1)
model = AutoEncoder2(input_dim=1000, z_dim=32,
             encodeLayer=[64], decodeLayer=[]) ## not use noise
print(model)

print(model.encoder[0].weight) 
x = torch.randn(1,1000)
model.forward_single(x)

结果如下