class AlexNet: def __init__(self, input_size=(227, 227, 3), classes=1000, learning_rate=1e-3): self.model = Sequential() self.model.add( Conv2D(96, (11, 11), strides=(4, 4), activation='relu', input_shape=input_size)) self.model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) self.model.add( Conv2D(256, (5, 5), strides=(1, 1), padding=2, activation='relu')) self.model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) self.model.add( Conv2D(384, (3, 3), strides=(1, 1), padding=1, activation='relu')) self.model.add( Conv2D(384, (3, 3), strides=(1, 1), padding=1, activation='relu')) self.model.add( Conv2D(256, (3, 3), strides=(1, 1), padding=1, activation='relu')) self.model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) self.model.add(Flatten()) self.model.add(Dropout(rate=0.5)) self.model.add(Dense(4096, activation='relu')) self.model.add(Dropout(rate=0.5)) self.model.add(Dense(4096, activation='relu')) self.model.add(Dense(classes, activation='relu')) self.model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.RMSprop(lr=learning_rate, decay=0.0005), metrics=['accuracy']) def fit(self, data, targets, batch_size=None): self.model.fit(data, targets, batch_size=batch_size, epochs=1, verbose=0) def accuracy(self, data, targets): return self.model.test_on_batch(data, targets)[1] def loss(self, data, targets): return self.model.test_on_batch(data, targets)[0]
class LeNet5: def __init__(self, input_size=(32, 32, 3), classes=2, learning_rate=1e-3): self.model = Sequential() self.model.add( Conv2D(6, kernel_size=(5, 5), strides=(1, 1), activation='relu', input_shape=input_size)) self.model.add(MaxPooling2D(pool_size=(2, 2))) self.model.add(Conv2D(16, (5, 5), activation='relu')) self.model.add(MaxPooling2D(pool_size=(2, 2))) self.model.add(Flatten()) self.model.add(Dense(120, activation='relu')) self.model.add(Dense(84, activation='relu')) self.model.add(Dense(classes, activation='softmax')) self.model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.SGD(lr=learning_rate), metrics=['accuracy']) def fit(self, data, targets, batch_size=None): self.model.fit(data, targets, batch_size=batch_size, epochs=1, verbose=0) def accuracy(self, data, targets): return self.model.test_on_batch(data, targets)[1] def loss(self, data, targets): return self.model.test_on_batch(data, targets)[0]
layer.trainable = True # for layer in model.layers: # print(layer.trainable) np.random.shuffle(train_read_index) label_train = label[train_read_index] for batch_id in range(num_batch): current_batch = extract_one_batch(train_read_index[batch_id*batch_size:(batch_id+1)*batch_size],\ train_dir) trian_loss_metrics = model.train_on_batch(x = current_batch, y = label_train[batch_id*batch_size:(batch_id+1)*batch_size]) print("%s epoch,%sst batch is training.. "%(epoch+1,batch_id+1)) print("train loss is ",trian_loss_metrics) f_log_train.write("epoch:"+str(epoch+1)+" "+"batch:"+str(batch_id+1)+" "+str(trian_loss_metrics[0])+"\n") f_log_train.flush() for batch_test_id in range(num_test_batch): current_batch = extract_one_batch(test_read_index[batch_test_id*batch_size:(batch_test_id+1)*batch_size],\ train_dir) test_loss_metrics = model.test_on_batch(current_batch,\ label_test[batch_test_id*batch_size:(batch_test_id+1)*batch_size]) # loss = np.mean(np.power(np.sum(np.power((pred - label_test[batch_test_id*batch_size:(batch_test_id+1)*batch_size]),2),axis = 1),0.5)) print("test loss and metrics is : ",test_loss_metrics) f_log_test.write("epoch:"+str(epoch+1)+" "+\ "batch:"+str(batch_test_id+1)+" "+str(test_loss_metrics[0])+"\n") f_log_test.flush() if if_save_model_trained: if (epoch+1)%save_interval == 0 and epoch>0 : model.save(log_dir+model_save_basename+str(epoch+1)+".h5") f_log_train.close() f_log_test.close()
class GAN: def __init__(self): self.batch_size = 32 self.log_step = 50 self.scaler = MinMaxScaler((-1, 1)) self.data = self.get_data_banknotes() self.init_model() # Logging loss self.logs_loss = pd.DataFrame(columns=['d_train_r', # real data from discriminator training 'd_train_f', # fake data from discriminator training 'd_test_r', # real data from discriminator testing 'd_test_f', # fake data from discriminator testing 'a' # data from GAN(adversarial) training ]) # Logging accuracy self.logs_acc = pd.DataFrame(columns=['d_train_r', 'd_train_f', 'd_test_r', 'd_test_f', 'a']) # Logging generated rows self.results = pd.DataFrame(columns=['iteration','variance', 'skewness', 'curtosis', 'entropy', 'prediction']) def get_data_banknotes(self): """ Get data from file :return: """ names = ['variance', 'skewness', 'curtosis', 'entropy', 'class'] dataset = pd.read_csv('data/data_banknotes.csv', names=names) dataset = dataset.loc[dataset['class'] == 0].values # only real banknotes, because fake ones will be generated X = dataset[:, :4] # omitting last column, we already know it will be 0 data = self.structure_data(X) return data def scale(self, X): return self.scaler.fit_transform(X) def descale(self, X): return self.scaler.inverse_transform(X) def structure_data(self, X): """ Structure data :param X: :return: """ data_subsets = {'normal': X, 'scaled': self.scale(X)} for subset, data in data_subsets.items(): # splitting each subset on train and test splited_data = train_test_split(data, test_size=0.3, shuffle=True) data_subsets.update({ subset: { 'train': splited_data[0], 'test': splited_data[1]} }) return data_subsets def init_discriminator(self): """ Init trainable discriminator model. Will be used for training and testing itself outside connected GAN model. LeakyReLU activation function, Adam optimizer and Dropout are recommended in GAN papers """ self.D = Sequential() self.D.add(Dense(16, input_dim=4)) self.D.add(LeakyReLU()) self.D.add(Dropout(0.3)) self.D.add(Dense(16)) self.D.add(LeakyReLU()) self.D.add(Dense(16)) self.D.add(LeakyReLU()) self.D.add(Dense(1, activation='sigmoid')) self.D.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) def init_discriminator_G(self): """ Init non-trainable discriminator model. Will be used for training generator inside connected GAN model. LeakyReLU activation function, Adam optimizer and Dropout are recommended in GAN papers """ self.Dg = Sequential() self.Dg.add(Dense(16, input_dim=4)) # activation function: ganhacks self.Dg.add(LeakyReLU()) self.Dg.add(Dropout(0.3)) self.Dg.add(Dense(16)) self.Dg.add(LeakyReLU()) self.Dg.add(Dense(16)) self.Dg.add(LeakyReLU()) # activation function: ganhacks self.Dg.add(Dense(1, activation='sigmoid')) self.Dg.trainable = False self.Dg.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) def init_generator(self): """ LeakyReLU activation function, Adam optimizer and Dropout are recommended in GAN papers for BOTH D and G """ self.G = Sequential() self.G.add(Dense(16, input_dim=64)) self.G.add(LeakyReLU()) self.G.add(Dropout(0.3)) self.G.add(Dense(16)) self.G.add(LeakyReLU()) self.G.add(GaussianNoise(0.1)) self.G.add(Dense(16)) self.G.add(LeakyReLU()) self.G.add(Dense(4, activation='tanh')) self.G.compile(loss='binary_crossentropy', optimizer='adam') def init_model(self): """ Connecting non trainable model with Generator. Initializing D. :return: """ self.init_discriminator() self.init_discriminator_G() self.init_generator() self.GAN = Sequential() self.GAN.add(self.G) self.GAN.add(self.Dg) self.GAN.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) def get_adversarial_data(self, mode='train'): """ Get data for adversarial training. """ data = self.data['scaled'][mode].copy() np.random.shuffle(data) features_real = data[:int(self.batch_size / 2)] # random rows with real data noise = np.random.uniform(-1.0, 1.0, size=[int(self.batch_size / 2), 64]) # random noise for generator features_fake = self.G.predict(noise) # fake data y_real = np.zeros([int(self.batch_size / 2), 1]) # array of zeros for real rows labels y_fake = np.ones([int(self.batch_size / 2), 1]) # array of ones for fake rows labels return features_real, y_real, features_fake, y_fake def train(self, train_steps): try: for i in range(train_steps): # Training D xr, yr, xf, yf = self.get_adversarial_data() # train D separately from G d_loss_r = self.D.train_on_batch(xr, yr) # separating real and fake data is recommended d_loss_f = self.D.train_on_batch(xf, yf) # Training G # flipping the label before prediction will # not influence D prediction as here D is not trainable and is getting weights from trainable D y = np.zeros([int(self.batch_size / 2), 1]) # flipping labels is recommended self.Dg.set_weights(self.D.get_weights()) # Copying weights from trainable D noise = np.random.uniform(-1.0, 1.0, size=[int(self.batch_size / 2), 64]) # getting input noise for G a_loss = self.GAN.train_on_batch(noise, y) # Testing xr_t, yr_t, xf_t, yf_t = self.get_adversarial_data(mode='test') d_pred_r = self.D.predict_on_batch(xr_t) # getting example predictions d_pred_f = self.D.predict_on_batch(xf_t) d_loss_r_t = self.D.test_on_batch(xr_t, yr_t) # getting loss and acc d_loss_f_t = self.D.test_on_batch(xf_t, yf_t) # Logging important data self.log(locals()) finally: """ Plot and save data when finished. """ self.plot() self.results.to_csv('results/results.csv', index=False) def plot(self): """ Preparing for plotting, plotting and saving plots. """ import matplotlib.pyplot as plt ax_loss = self.logs_loss.plot(linewidth=0.75, figsize=(20, 10)) ax_loss.set_xlabel('iteration') ax_loss.set_ylabel('loss') fig = plt.gcf() fig.set_dpi(200) plt.legend(loc='upper right', framealpha=0, prop={'size': 'large'}) fig.savefig('results/loss.png', dpi=200) ax_acc = self.logs_acc.plot(linewidth=0.75, figsize=(20, 10)) ax_acc.set_xlabel('iteration') ax_acc.set_ylabel('accuracy') fig = plt.gcf() fig.set_dpi(200) plt.legend(loc='upper right', framealpha=0, prop={'size': 'large'}) fig.savefig('results/acc.png', dpi=200) plt.show() def log(self, variables): """ Logging and printing all the necessary data """ r_rows = pd.DataFrame(self.descale(variables['xr_t']), columns=['variance', 'skewness', 'curtosis', 'entropy']) r_rows['prediction'] = variables['d_pred_r'] f_rows = pd.DataFrame(self.descale(variables['xf_t']), columns=['variance', 'skewness', 'curtosis', 'entropy']) f_rows['prediction'] = variables['d_pred_f'] f_rows['iteration'] = variables['i'] self.logs_loss = self.logs_loss.append(pd.Series( # logging loss [variables['d_loss_r'][0], variables['d_loss_f'][0], variables['d_loss_r_t'][0], variables['d_loss_f_t'][0], variables['a_loss'][0]], index=self.logs_loss.columns), ignore_index=True) self.logs_acc = self.logs_acc.append(pd.Series( # logging acc [variables['d_loss_r'][1], variables['d_loss_f'][1], variables['d_loss_r_t'][1], variables['d_loss_f_t'][1], variables['a_loss'][1]], index=self.logs_loss.columns), ignore_index=True) self.results = self.results.append(f_rows, ignore_index=True, sort=False) # logging generated data if self.log_step and variables['i'] % self.log_step == 0: # print metrics every 'log_step' iteration # preparing strings for printing log_msg = f""" Batch {variables['i']}: D(training): loss: real : {variables['d_loss_r'][0]:.4f} fake : {variables['d_loss_f'][0]:.4f} acc: real: {variables['d_loss_r'][1]:.4f} fake: {variables['d_loss_f'][1]:.4f} D(testing): loss: real : {variables['d_loss_r_t'][0]:.4f} fake : {variables['d_loss_f_t'][0]:.4f} acc: real: {variables['d_loss_r_t'][1]:.4f} fake: {variables['d_loss_f_t'][1]:.4f} GAN: loss: {variables['a_loss'][0]:.4f} acc: {variables['a_loss'][1]:.4f} """ print(log_msg) np.set_printoptions(precision=5, linewidth=140, suppress=True) # set how np.array will be printed predictions = f""" Example results: Real rows: {r_rows} Fake rows: {f_rows} """ print(predictions)
class VGG19: def __init__(self, input_size=(224, 224, 3), classes=1000, learning_rate=1e-3): self.model = Sequential() self.model.add( Conv2D(64, (3, 3), activation='relu', input_shape=input_size)) self.model.add( Conv2D(64, (3, 3), activation='relu', input_shape=input_size)) self.model.add(MaxPooling2D(pool_size=(2, 2))) self.model.add( Conv2D(128, (3, 3), activation='relu', input_shape=input_size)) self.model.add( Conv2D(128, (3, 3), activation='relu', input_shape=input_size)) self.model.add(MaxPooling2D(pool_size=(2, 2))) self.model.add( Conv2D(256, (3, 3), activation='relu', input_shape=input_size)) self.model.add( Conv2D(256, (3, 3), activation='relu', input_shape=input_size)) self.model.add(MaxPooling2D(pool_size=(2, 2))) self.model.add( Conv2D(512, (3, 3), activation='relu', input_shape=input_size)) self.model.add( Conv2D(512, (3, 3), activation='relu', input_shape=input_size)) self.model.add(MaxPooling2D(pool_size=(2, 2))) self.model.add( Conv2D(512, (3, 3), activation='relu', input_shape=input_size)) self.model.add( Conv2D(512, (3, 3), activation='relu', input_shape=input_size)) self.model.add(MaxPooling2D(pool_size=(2, 2))) self.model.add(Dense(4096, activation='relu')) self.model.add(Dense(4096, activation='relu')) self.model.add(Dense(classes, activation='relu')) self.model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.RMSprop(lr=learning_rate, decay=0.0005), metrics=['accuracy']) def fit(self, data, targets, batch_size=None): self.model.fit(data, targets, batch_size=batch_size, epochs=1, verbose=0) def accuracy(self, data, targets): return self.model.test_on_batch(data, targets)[1] def loss(self, data, targets): return self.model.test_on_batch(data, targets)[0]