def activate(self, param): inp = self.result with tf.name_scope('activation_' + str(self.layernum)): if param == 0: res = L.relu(inp, name='relu_' + str(self.layernum)) elif param == 1: res = L.lrelu(inp, name='lrelu_' + str(self.layernum)) elif param == 2: res = L.elu(inp, name='elu_' + str(self.layernum)) elif param == 3: res = L.tanh(inp, name='tanh_' + str(self.layernum)) elif param == 4: self.inpsize[-1] = self.inpsize[-1] // 2 res = L.MFM(inp, self.inpsize[-1], name='mfm_' + str(self.layernum)) elif param == 5: self.inpsize[-1] = self.inpsize[-1] // 2 res = L.MFMfc(inp, self.inpsize[-1], name='mfm_' + str(self.layernum)) elif param == 6: res = L.sigmoid(inp, name='sigmoid_' + str(self.layernum)) else: res = inp self.result = res return self.result
def __init__(self, z_dim, conv_dim, num_classes): super(Generator, self).__init__() self.conv_dim = conv_dim self.linear = spectral_norm( linear(in_features=z_dim, out_features=conv_dim * 16 * 4 * 4)) self.res_1 = ResidualBlock_G(conv_dim * 16, conv_dim * 16, num_classes) self.res_2 = ResidualBlock_G(conv_dim * 16, conv_dim * 8, num_classes) self.res_3 = ResidualBlock_G(conv_dim * 8, conv_dim * 4, num_classes) self.attn = SelfAttn(conv_dim * 4) self.res_4 = ResidualBlock_G(conv_dim * 4, conv_dim * 2, num_classes) self.res_5 = ResidualBlock_G(conv_dim * 2, conv_dim, num_classes) self.bn = batch_norm(conv_dim, eps=1e-5, momentum=0.0001) self.lrelu = lrelu(inplace=True) self.conv3x3 = spectral_norm(conv3x3(conv_dim, 3)) self.tanh = tanh() self.apply(init_weights)
def convTest3(): data = np.random.random((100, 2,1)) labs = np.array(list(map(test, data))) labels = [] count = 0 print(labs) for lab in labs: if lab == 1: labels.append([0,1]) count += 1 else: labels.append([1,0]) print(count) inp = layers.convLayer(3, 3, 1) conv1 = layers.convLayer(3, 3, 3) conv2 = layers.convLayer(3,3,3) sig = layers.tanh() dense = layers.denseLayer(6, 2) soft = layers.softMax() cost = layers.sumSquareError() for i in range(3000): itError = 0 epochCorrect = 0 correct = False for dat, label in zip(data, labels): datum = inp.eval([dat]) c1= conv1.eval(datum) c1s = sig.eval(c1) c2 = conv2.eval(c1s) c2s = sig.eval(c2) #print("Val1", val1.shape) shmush = c2s.reshape((6)) #print("Shmush", shmush) val2 = dense.eval(shmush) sof = soft.eval(val2) #print(sof, label) if label[0] == 1 and sof[0] > sof[1]: correct = True epochCorrect+=1 #print("Correct :", sof[0], ">", sof[1]) elif label[1] ==1 and sof[1] > sof[0]: correct = True epochCorrect+=1 #print("Correct :", sof[0], "<", sof[1]) else: #print("Incorrect :", sof[0], " ", sof[1]) pass error = cost.eval(sof, label) #print("Error", error) itError += error if True: Derror = cost.setUpdate(sof, label) Dsof = soft.setUpdate(val2, Derror) #print("Derror", Derror) Ddense = dense.setUpdate(shmush, Dsof) #print("DDense", Ddense) DunShmush = Ddense.reshape((3, 2, 1)) #print("Unshmush", DunShmush.shape) #print("DUnShmush", DunShmush) dc2s = sig.setUpdate(c2, DunShmush) dc2 = conv2.setUpdate(c1s, dc2s) dc1s = sig.setUpdate(c1, dc2) dc1 = conv1.setUpdate(datum,dc1s) dInp = inp.setUpdate([dat], dc1) conv1.doUpdate(lr= .01) conv2.doUpdate(lr = .01) dense.doUpdate(lr = .01) inp.doUpdate(lr = .01) print(i, ": ", itError, "Accuracy : ", epochCorrect)
def __init__(self, image_size=64, z_dim=100, conv_dim=64): super(Generator, self).__init__() layer1 = [] layer2 = [] layer3 = [] layer4 = [] output = [] # layer 1 layer_num = int(np.log2(image_size)) - 3 # 3 mult = 2**layer_num # 8 output_dim = conv_dim * mult # 512 # 100 -> 512 layer1.append(spectral_norm(deconv(z_dim, output_dim, kernel_size=4))) layer1.append(batch_norm(output_dim)) layer1.append(lrelu()) # layer 2 input_dim = output_dim output_dim = int(input_dim / 2) # 512 -> 256 layer2.append( spectral_norm( deconv(input_dim, output_dim, kernel_size=4, stride=2, padding=1))) layer2.append(batch_norm(output_dim)) layer2.append(lrelu()) # layer 3 input_dim = output_dim output_dim = int(input_dim / 2) # 256 -> 128 layer3.append( spectral_norm( deconv(input_dim, output_dim, kernel_size=4, stride=2, padding=1))) layer3.append(batch_norm(output_dim)) layer3.append(lrelu()) # layer 4 input_dim = output_dim output_dim = int(input_dim / 2) # 128 -> 64 layer4.append( spectral_norm( deconv(input_dim, output_dim, kernel_size=4, stride=2, padding=1))) layer4.append(batch_norm(output_dim)) layer4.append(lrelu()) # output layer input_dim = output_dim # 64 -> 3 output.append( deconv(input_dim, out_channels=3, kernel_size=4, stride=2, padding=1)) output.append(tanh()) self.l1 = nn.Sequential(*layer1) self.l2 = nn.Sequential(*layer2) self.l3 = nn.Sequential(*layer3) self.attn1 = SelfAttn(128) self.l4 = nn.Sequential(*layer4) self.attn2 = SelfAttn(64) self.output = nn.Sequential(*output)