def main(): (x_train, y_train), (x_validation, y_validation) = load_data() model = Model(*juxt(identity, computational_graph(y_train.shape[1]))(Input(shape=x_train.shape[1:]))) model.compile(loss='categorical_crossentropy', optimizer=SGD(momentum=0.9), metrics=['accuracy']) model.summary() # plot_model(model, to_file='./results/model.png') train_data = ImageDataGenerator(featurewise_center=True, featurewise_std_normalization=True, width_shift_range=0.125, height_shift_range=0.125, horizontal_flip=True) validation_data = ImageDataGenerator(featurewise_center=True, featurewise_std_normalization=True) for data in (train_data, validation_data): data.fit(x_train) # 実用を考えると、x_validationでのfeaturewiseのfitは無理だと思う……。 batch_size = 100 epochs = 200 results = model.fit_generator(train_data.flow(x_train, y_train, batch_size=batch_size), steps_per_epoch=x_train.shape[0] // batch_size, epochs=epochs, callbacks=[LearningRateScheduler(partial(getitem, tuple(take(epochs, concat(repeat(0.01, 1), repeat(0.1, 99), repeat(0.01, 50), repeat(0.001))))))], validation_data=validation_data.flow(x_validation, y_validation, batch_size=batch_size), validation_steps=x_validation.shape[0] // batch_size) with open('./results/history.pickle', 'wb') as f: pickle.dump(results.history, f) save_model(model, './results/model.h5') del model
def main(): (waves, labels), (x_validate, y_validate) = load_data() x_mean = 4.3854903e-05 # np.concatenate(waves).mean() x_std = 0.042366702 # np.concatenate(waves).std() waves = tuple(map(lambda wave: (wave - x_mean) / x_std, waves)) x_validate = (x_validate - x_mean) / x_std model = Model( *juxt(identity, computational_graph(max(y_validate) + 1))(Input( shape=x_validate.shape[1:]))) model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.summary() batch_size = 50 epoch_size = 500 results = model.fit_generator( data_generator(waves, labels, batch_size), steps_per_epoch=8000 // batch_size, epochs=epoch_size, validation_data=(x_validate, y_validate), callbacks=[ReduceLROnPlateau(factor=0.5, patience=50, verbose=1)]) with open('./results/history.pickle', 'wb') as f: pickle.dump(results.history, f) save_model(model, './results/model.h5') del model
def print_predicts(): _, (x, y) = load_data() x = (x - 4.3854903e-05) / 0.042366702 model = load_model('./results/model.h5', custom_objects={'ZeroPadding': ZeroPadding}) y_pred = np.argmax(model.predict(x), axis=1) for t, p in zip(y, y_pred): print('{0}\t{1}'.format(labels[t], labels[p])) del model
def run(args): domains_summary() parameters_summary() train_params = { 'batch_size': args.train_batch_size, 'shuffle': args.train_data_set_shuffle } if args.model == 'AutoEncoder': ae_model = SimpleAutoEncoder(ast.literal_eval(args.autoencoder_shape)) ae_model.summary() c_optimizer = torch.optim.SGD(ae_model.decoder.parameters(), lr=args.learning_rate) d_optimizer = torch.optim.SGD(ae_model.domain_classifier.parameters(), lr=args.learning_rate) f_optimizer = torch.optim.SGD(ae_model.encoder.parameters(), lr=args.learning_rate) c_scheduler = ReduceLROnPlateau(c_optimizer, mode='min', factor=args.reduce_lr_factor, patience=args.reduce_lr_patience) d_scheduler = ReduceLROnPlateau(d_optimizer, mode='min', factor=args.reduce_lr_factor, patience=args.reduce_lr_patience) #criterion = args.loss criterion = ReversalLoss() # src_domain_data_set, tgt_domain_data_set = load_data('kitchen', 'books', verbose=True) # words_to_reconstruct = get_unique_per_set_words(src_domain_data_set, tgt_domain_data_set) data_generator = as_one_dataloader( args.src_domain, args.tgt_domain, train_params, denoising_factor=args.denoising_factor ) #, words_to_reconstruct=words_to_reconstruct) trainer = AutoEncoderTrainer(ae_model, criterion, c_optimizer, d_optimizer, f_optimizer, c_scheduler, d_scheduler, args.max_epochs, epochs_no_improve=args.epochs_no_improve) trainer.fit(data_generator) torch.save(ae_model.state_dict(), args.ae_model_file) print('Model was saved in {} file.'.format(args.ae_model_file)) elif args.model == 'ATTFeedforward': src_domain_data_set, tgt_domain_data_set = load_data(args.src_domain, args.tgt_domain, verbose=True) train_generator, valid_generator, target_generator = train_valid_target_split( src_domain_data_set, tgt_domain_data_set, train_params) ae_model = None if args.auto_encoder_embedding is not None: ae_model = SimpleAutoEncoder( ast.literal_eval(args.autoencoder_shape)) ae_model.load_state_dict(torch.load(args.auto_encoder_embedding)) ae_model.set_train_mode(False) # don't froze the AutoEncoder! # ae_model.froze() ae_model.eval() attff_model = ATTFeedforward(args.attff_input_size, args.attff_hidden_size, ae_model) attff_model.summary() criterion = MultiViewLoss() criterion_t = CrossEntropyLoss() optimizer = torch.optim.Adam(attff_model.parameters(), lr=args.learning_rate) scheduler = ReduceLROnPlateau(optimizer, factor=args.reduce_lr_factor, patience=args.reduce_lr_patience) trainer = DomainAdaptationTrainer( attff_model, criterion, criterion_t, optimizer, scheduler, args.max_epochs, ae_model=ae_model, epochs_no_improve=args.epochs_no_improve) if args.load_attnn_model: attff_model.load_state_dict( torch.load( args.attnn_model_file.format(args.attff_input_size, args.attff_hidden_size))) else: trainer.fit(train_generator, valid_generator, target_generator=target_generator, max_epochs=args.max_epochs) model_file = args.attnn_model_file.format(args.attff_input_size, args.attff_hidden_size) torch.save(attff_model.state_dict(), model_file) print('Model was saved in {} file.'.format(model_file)) trainer.pseudo_label(train_generator, valid_generator, tgt_domain_data_set, iterations=args.pseudo_label_iterations, train_params=train_params, max_epochs=args.max_epochs)
from data_set import AmazonDomainDataSet, train_valid_target_split, load_data from utils.data import build_dictionary def get_unique_per_set_words(data_set1: AmazonDomainDataSet, data_set2: AmazonDomainDataSet): dictionary = build_dictionary([data_set1, data_set2], 5000) set1_words = set() set2_words = set() for i, row in data_set1.data.iterrows(): for word in row.acl_processed: if word[0] in dictionary: set1_words.add(word[0]) for i, row in data_set2.data.iterrows(): for word in row.acl_processed: if word[0] in dictionary: set2_words.add(word[0]) return set([word for word in set1_words if word not in set2_words]).union( set([word for word in set2_words if word not in set1_words])) src_domain_data_set, tgt_domain_data_set = load_data('books', 'kitchen', verbose=True) get_unique_per_set_words(src_domain_data_set, tgt_domain_data_set)
import data_set import id3 import numpy as np data, labels = data_set.load_data("data\\agaricus-lepiota.data") # tree display prompt display_trees = input("Display trees? (y/n): ") id3_type = input("Algorytm zwykły czy z ruletką? (regular/roulette): ") # data_set.display_data(data, 10, [i for i in range(23)]) f = 0.1 f = float(input("Podaj rozmiar zbioru treningowego (float): ")) training_data_length = int(len(data) * f) # 0.5% of data is training data k = 1 #numer of repeats k = int(input("Podaj ilość testów (int): ")) while (k > 0): #randomize data order np.random.shuffle(data) training_data = data[:training_data_length, 1:] training_labels = data[:training_data_length, 0] id3_tree = id3.build_tree(training_labels, training_data, variation=id3_type) #roulette or regular
def main(): import os with tf.device("/cpu:0"): (x_train, y_train), (x_validation, y_validation) = load_data() batch_size = 32 epochs = 200 input_shape = Input(shape=x_train.shape[1:]) model_file = './results/model.h5' if os.path.exists(model_file): model = load_model(model_file) # with tf.device("/cpu:0"): # validation_data = ImageDataGenerator(featurewise_center=True, featurewise_std_normalization=True) else: model = Model(*juxt(identity, computational_graph(y_train.shape[1]))( input_shape)) model.compile(loss='categorical_crossentropy', optimizer=SGD(momentum=0.9), metrics=['accuracy']) with tf.device("/cpu:0"): train_data = ImageDataGenerator(featurewise_center=True, featurewise_std_normalization=True, width_shift_range=0.125, height_shift_range=0.125, horizontal_flip=True) validation_data = ImageDataGenerator( featurewise_center=True, featurewise_std_normalization=True) for data in (train_data, validation_data): data.fit( x_train) # 実用を考えると、x_validationでのfeaturewiseのfitは無理だと思う……。 results = model.fit_generator( train_data.flow(x_train, y_train, batch_size=batch_size), steps_per_epoch=x_train.shape[0] // batch_size, epochs=epochs, callbacks=[ LearningRateScheduler( partial( getitem, tuple( take( epochs, concat(repeat(0.01, 1), repeat(0.1, 99), repeat(0.01, 50), repeat(0.001)))))) ], validation_data=validation_data.flow(x_validation, y_validation, batch_size=batch_size), validation_steps=x_validation.shape[0] // batch_size) with open('./results/history.pickle', 'wb') as f: pickle.dump(results.history, f) save_model(model, model_file) try: with tf.device("/cpu:0"): # model.summary() # print("=== AFTER POPPING THE LAST ===") model.layers.pop() # model.summary() # generate_confusion_matrix(model, x_validation, y_validation, batch_size) # plot_model(model, to_file='./results/model.png') except Exception as ex: print("plot_model failed with error:", repr(ex), "\nMoving on...") siamese(input_shape, model)
model.label: np.expand_dims(y, axis=1), model.dropout_keep_fm: [1.0] * len(dfm_params['dropout_fm']), model.dropout_keep_deep: [1.0] * len(dfm_params['dropout_deep']), model.train_phase: False } logits = sess.run([model.out], feed_dict=feed_dict) #最后一个batch大小可能与之前的不一样 if i == 0: y_pred = np.reshape(logits[0], [-1, 1]) else: y_pred = np.concatenate((y_pred, np.reshape(logits[0], [-1, 1]))) return y_pred if __name__ == '__main__': train_df, test_df, x_train, y_train, x_test, ids_test, cat_features_indices = load_data( ) print(train_df) # k折交叉验证 folds = list(StratifiedKFold(n_splits=config.NUM_SPLITS, shuffle=True,\ random_state=config.RANDOM_SEED).split(x_train, y_train)) fd = FeatureDictionary(dfTrain=train_df, dfTest=test_df,\ numeric_cols=config.NUMERIC_COLS,\ ignore_cols=config.IGNORE_COLS) # data_parser = DataParser(feat_dict=fd) #Xi_train训练数据中特征编号,Xv_train是Xi_train对应的特征编号下的特征值,连续型特征则是该特征值 Xi_train, Xv_train, y_train = data_parser.parse(df=train_df, has_label=True) Xi_test, Xv_test, ids_test = data_parser.parse(df=test_df)