def train(embeddings_name, fold_count, architecture="gru", transformer=None): batch_size, maxlen, patience, early_stop, max_epoch = configure( architecture) model = Classifier('citations_' + architecture, architecture=architecture, list_classes=list_classes, max_epoch=max_epoch, fold_number=fold_count, use_roc_auc=True, embeddings_name=embeddings_name, batch_size=batch_size, maxlen=maxlen, patience=patience, early_stop=early_stop, class_weights=class_weights, transformer_name=transformer) print('loading citation sentiment corpus...') xtr, y = load_citation_sentiment_corpus( "data/textClassification/citations/citation_sentiment_corpus.txt") if fold_count == 1: model.train(xtr, y) else: model.train_nfold(xtr, y) # saving the model model.save()
def train(embeddings_name, fold_count, architecture="gru", transformer=None): print('loading binary software use dataset...') xtr, y = load_software_use_corpus_json( "data/textClassification/software/software-use.json.gz") model_name = 'software_use_' + architecture class_weights = None batch_size, maxlen, patience, early_stop, max_epoch = configure( architecture) model = Classifier(model_name, architecture=architecture, list_classes=list_classes, max_epoch=max_epoch, fold_number=fold_count, patience=patience, use_roc_auc=True, embeddings_name=embeddings_name, batch_size=batch_size, maxlen=maxlen, early_stop=early_stop, class_weights=class_weights, transformer_name=transformer) if fold_count == 1: model.train(xtr, y) else: model.train_nfold(xtr, y) # saving the model model.save()
def train_and_eval_primary(embeddings_name, fold_count, use_ELMo=False, use_BERT=False, architecture="gru"): print('loading dataset type corpus...') xtr, y, _, _, list_classes, _, _ = load_dataseer_corpus_csv( "data/textClassification/dataseer/all-1.csv") # distinct values of classes print(list_classes) print(len(list_classes), "classes") print(len(xtr), "texts") print(len(y), "classes") class_weights = None batch_size = 256 maxlen = 300 if use_ELMo: batch_size = 20 elif use_BERT: batch_size = 50 # default bert model parameters if architecture.find("bert") != -1: batch_size = 32 maxlen = 100 model = Classifier('dataseer', model_type=architecture, list_classes=list_classes, max_epoch=100, fold_number=fold_count, patience=10, use_roc_auc=True, embeddings_name=embeddings_name, use_ELMo=use_ELMo, use_BERT=use_BERT, batch_size=batch_size, maxlen=maxlen, class_weights=class_weights) # segment train and eval sets x_train, y_train, x_test, y_test = split_data_and_labels(xtr, y, 0.9) print(len(x_train), "train texts") print(len(y_train), "train classes") print(len(x_test), "eval texts") print(len(y_test), "eval classes") if fold_count == 1: model.train(x_train, y_train) else: model.train_nfold(x_train, y_train) model.eval(x_test, y_test) # saving the model model.save()
def train(embeddings_name, fold_count, use_ELMo=False): batch_size = 256 if use_ELMo: batch_size = 20 model = Classifier('citations', "gru", list_classes=list_classes, max_epoch=70, fold_number=fold_count, use_roc_auc=True, embeddings_name=embeddings_name, use_ELMo=use_ELMo, batch_size=batch_size, class_weights=class_weights) print('loading citation sentiment corpus...') xtr, y = load_citation_sentiment_corpus( "data/textClassification/citations/citation_sentiment_corpus.txt") if fold_count == 1: model.train(xtr, y) else: model.train_nfold(xtr, y) # saving the model model.save()
def train_and_eval(embeddings_name, fold_count, use_ELMo=False): batch_size = 256 if use_ELMo: batch_size = 20 model = Classifier('citations', "gru", list_classes=list_classes, max_epoch=70, fold_number=fold_count, use_roc_auc=True, embeddings_name=embeddings_name, use_ELMo=use_ELMo, batch_size=batch_size, class_weights=class_weights) print('loading citation sentiment corpus...') xtr, y = load_citation_sentiment_corpus( "data/textClassification/citations/citation_sentiment_corpus.txt") # segment train and eval sets x_train, y_train, x_test, y_test = split_data_and_labels(xtr, y, 0.9) if fold_count == 1: model.train(x_train, y_train) else: model.train_nfold(x_train, y_train) model.eval(x_test, y_test) # saving the model model.save()
def train(embeddings_name=None, fold_count=1, architecture="gru", transformer=None): batch_size, maxlen, patience, early_stop, max_epoch = configure( architecture) model = Classifier('toxic_' + architecture, architecture, list_classes=list_classes, max_epoch=max_epoch, fold_number=fold_count, class_weights=class_weights, embeddings_name=embeddings_name, batch_size=batch_size, maxlen=maxlen, patience=patience, early_stop=early_stop, transformer_name=transformer) print('loading train dataset...') xtr, y = load_texts_and_classes_pandas( "data/textClassification/toxic/train.csv") if fold_count == 1: model.train(xtr, y) else: model.train_nfold(xtr, y) # saving the model model.save()
def train(embeddings_name, fold_count, use_ELMo=False, use_BERT=False, architecture="gru"): batch_size, maxlen = configure(architecture, use_BERT, use_ELMo) model = Classifier('citations', model_type=architecture, list_classes=list_classes, max_epoch=100, fold_number=fold_count, patience=10, use_roc_auc=True, embeddings_name=embeddings_name, use_ELMo=use_ELMo, use_BERT=use_BERT, batch_size=batch_size, maxlen=maxlen, class_weights=class_weights) print('loading citation sentiment corpus...') xtr, y = load_citation_sentiment_corpus( "data/textClassification/citations/citation_sentiment_corpus.txt") if fold_count == 1: model.train(xtr, y) else: model.train_nfold(xtr, y) # saving the model model.save()
def classify(texts, output_format): # load model model = Classifier('toxic', "gru", list_classes=list_classes) model.load() start_time = time.time() result = model.predict(texts, output_format) print("runtime: %s seconds " % (round(time.time() - start_time, 3))) return result
def classify(texts, output_format, architecture="gru", transformer=None): # load model model = Classifier('toxic_' + architecture) model.load() start_time = time.time() result = model.predict(texts, output_format) print("runtime: %s seconds " % (round(time.time() - start_time, 3))) return result
def train_and_eval(embeddings_name, fold_count, use_ELMo=False, use_BERT=False, architecture="gru"): print('loading binary software use dataset...') xtr, y = load_software_use_corpus_json( "data/textClassification/software/software-use.json.gz") nb_used = 0 for the_class in y: if the_class[1] == 1.0: nb_used += 1 nb_unused = len(y) - nb_used print("\ttotal:", len(y)) print("\tused:", nb_used) print("\tnot used:", nb_unused) model_name = 'software_use' class_weights = None if use_ELMo: model_name += '-with_ELMo' elif use_BERT: model_name += '-with_BERT' # segment train and eval sets x_train, y_train, x_test, y_test = split_data_and_labels(xtr, y, 0.9) batch_size, maxlen = configure(architecture, use_BERT, use_ELMo) print(list_classes) model = Classifier(model_name, model_type=architecture, list_classes=list_classes, max_epoch=100, fold_number=fold_count, patience=10, use_roc_auc=True, embeddings_name=embeddings_name, use_ELMo=use_ELMo, use_BERT=use_BERT, batch_size=batch_size, maxlen=maxlen, class_weights=class_weights) if fold_count == 1: model.train(x_train, y_train) else: model.train_nfold(x_train, y_train) model.eval(x_test, y_test) # saving the model model.save()
def classify(texts, output_format): # load model model = Classifier('citations', "gru", list_classes=list_classes) model.load() start_time = time.time() result = model.predict(texts, output_format) runtime = round(time.time() - start_time, 3) if output_format is 'json': result["runtime"] = runtime else: print("runtime: %s seconds " % (runtime)) return result
def test(): # load model model = Classifier('toxic', "gru", list_classes=list_classes) model.load() print('loading test dataset...') xte = load_texts_pandas("data/textClassification/toxic/test.csv") print('number of texts to classify:', len(xte)) start_time = time.time() result = model.predict(xte, output_format="csv") print("runtime: %s seconds " % (round(time.time() - start_time, 3))) return result
def train_and_eval_binary(embeddings_name, fold_count, architecture="gru", transformer=None): print('loading multiclass software context dataset...') xtr, y = load_software_context_corpus_json( "data/textClassification/software/software-contexts.json.gz") report_training_contexts(y) # segment train and eval sets x_train, y_train, x_test, y_test = split_data_and_labels(xtr, y, 0.9) for class_rank in range(len(list_classes)): model_name = 'software_context_' + list_classes[ class_rank] + '_' + architecture class_weights = None batch_size, maxlen, patience, early_stop, max_epoch = configure( architecture) y_train_class_rank = [[1, 0] if y[class_rank] == 1.0 else [0, 1] for y in y_train] y_test_class_rank = [[1, 0] if y[class_rank] == 1.0 else [0, 1] for y in y_test] y_train_class_rank = np.array(y_train_class_rank) y_test_class_rank = np.array(y_test_class_rank) list_classes_rank = [ list_classes[class_rank], "not_" + list_classes[class_rank] ] model = Classifier(model_name, architecture=architecture, list_classes=list_classes_rank, max_epoch=max_epoch, fold_number=fold_count, patience=patience, use_roc_auc=True, embeddings_name=embeddings_name, batch_size=batch_size, maxlen=maxlen, early_stop=early_stop, class_weights=class_weights, transformer_name=transformer) if fold_count == 1: model.train(x_train, y_train_class_rank) else: model.train_nfold(x_train, y_train_class_rank) model.eval(x_test, y_test_class_rank)
def train_and_eval_reuse(embeddings_name, fold_count, architecture="gru", transformer=None): print('loading dataset type corpus...') xtr, y, _, _, list_classes, _, _ = load_dataseer_corpus_csv( "data/textClassification/dataseer/all-reuse.csv") # distinct values of classes print(list_classes) print(len(list_classes), "classes") print(len(xtr), "texts") print(len(y), "classes") batch_size, maxlen, patience, early_stop, max_epoch = configure( architecture) class_weights = {0: 1.5, 1: 1.} model = Classifier('dataseer-reuse_' + architecture, architecture=architecture, list_classes=list_classes, max_epoch=max_epoch, fold_number=fold_count, use_roc_auc=True, embeddings_name=embeddings_name, batch_size=batch_size, maxlen=maxlen, patience=patience, early_stop=early_stop, class_weights=class_weights, transformer_name=transformer) # segment train and eval sets x_train, y_train, x_test, y_test = split_data_and_labels(xtr, y, 0.9) print(len(x_train), "train texts") print(len(y_train), "train classes") print(len(x_test), "eval texts") print(len(y_test), "eval classes") if fold_count == 1: model.train(x_train, y_train) else: model.train_nfold(x_train, y_train) model.eval(x_test, y_test) # saving the model model.save()
def train(embeddings_name="fasttext-crawl", fold_count=1, use_ELMo=False, use_BERT=False, architecture="gru"): batch_size = 256 maxlen = 300 model = Classifier('toxic', architecture, list_classes=list_classes, max_epoch=30, fold_number=fold_count, class_weights=class_weights, embeddings_name=embeddings_name, use_ELMo=use_ELMo, use_BERT=use_BERT, batch_size=batch_size, maxlen=maxlen) print('loading train dataset...') xtr, y = load_texts_and_classes_pandas("data/textClassification/toxic/train.csv") if fold_count == 1: model.train(xtr, y) else: model.train_nfold(xtr, y) # saving the model model.save()
def train_and_eval(embeddings_name, fold_count, architecture="gru", transformer=None): print('loading binary software use dataset...') xtr, y = load_software_use_corpus_json( "data/textClassification/software/software-use.json.gz") nb_used = 0 for the_class in y: if the_class[1] == 1.0: nb_used += 1 nb_unused = len(y) - nb_used print("\ttotal:", len(y)) print("\tused:", nb_used) print("\tnot used:", nb_unused) model_name = 'software_use_' + architecture class_weights = None # segment train and eval sets x_train, y_train, x_test, y_test = split_data_and_labels(xtr, y, 0.9) batch_size, maxlen, patience, early_stop, max_epoch = configure( architecture) print(list_classes) model = Classifier(model_name, architecture=architecture, list_classes=list_classes, max_epoch=max_epoch, fold_number=fold_count, patience=patience, use_roc_auc=True, embeddings_name=embeddings_name, batch_size=batch_size, maxlen=maxlen, early_stop=early_stop, class_weights=class_weights, transformer_name=transformer) if fold_count == 1: model.train(x_train, y_train) else: model.train_nfold(x_train, y_train) model.eval(x_test, y_test) # saving the model model.save()
def classify(texts, output_format, architecture="gru"): # load model model = Classifier('software_use', model_type=architecture, list_classes=list_classes) model.load() start_time = time.time() result = model.predict(texts, output_format) runtime = round(time.time() - start_time, 3) if output_format is 'json': result["runtime"] = runtime else: print("runtime: %s seconds " % (runtime)) return result
def classify(texts, output_format, architecture="gru", cascaded=False): ''' Classify a list of texts with an existing model ''' # load model model = Classifier('dataseer', model_type=architecture) model.load() start_time = time.time() result = model.predict(texts, output_format) runtime = round(time.time() - start_time, 3) if output_format is 'json': result["runtime"] = runtime else: print("runtime: %s seconds " % (runtime)) return result
def classify(texts, output_format, embeddings_name=None, architecture="gru", transformer=None): # load model model = Classifier('software_context_' + architecture) model.load() start_time = time.time() result = model.predict(texts, output_format) runtime = round(time.time() - start_time, 3) if output_format == 'json': result["runtime"] = runtime else: print("runtime: %s seconds " % (runtime)) return result
def train(embeddings_name, fold_count): model = Classifier('toxic', "gru", list_classes=list_classes, max_epoch=30, fold_number=fold_count, embeddings_name=embeddings_name) print('loading train dataset...') xtr, y = load_texts_and_classes_pandas( "data/textClassification/toxic/train.csv") if fold_count == 1: model.train(xtr, y) else: model.train_nfold(xtr, y) # saving the model model.save()
def train_and_eval(embeddings_name, fold_count, architecture="gru", transformer=None): print('loading multiclass software context dataset...') xtr, y = load_software_context_corpus_json( "data/textClassification/software/software-contexts.json.gz") report_training_contexts(y) model_name = 'software_context_' + architecture class_weights = None # segment train and eval sets x_train, y_train, x_test, y_test = split_data_and_labels(xtr, y, 0.9) batch_size, maxlen, patience, early_stop, max_epoch = configure( architecture) print(list_classes) model = Classifier(model_name, architecture=architecture, list_classes=list_classes, max_epoch=max_epoch, fold_number=fold_count, patience=patience, use_roc_auc=True, embeddings_name=embeddings_name, batch_size=batch_size, maxlen=maxlen, early_stop=early_stop, class_weights=class_weights, transformer_name=transformer) if fold_count == 1: model.train(x_train, y_train) else: model.train_nfold(x_train, y_train) model.eval(x_test, y_test) # saving the model model.save()
def train(embeddings_name, fold_count): model = Classifier('citations', "gru", list_classes=list_classes, max_epoch=70, fold_number=fold_count, use_roc_auc=True, embeddings_name=embeddings_name) print('loading citation sentiment corpus...') xtr, y = load_citation_sentiment_corpus( "data/textClassification/citations/citation_sentiment_corpus.txt") if fold_count == 1: model.train(xtr, y) else: model.train_nfold(xtr, y) # saving the model model.save()
def train(embeddings_name, fold_count, use_ELMo=False, use_BERT=False, architecture="gru"): print('loading binary software use dataset...') xtr, y = load_software_use_corpus_json( "data/textClassification/software/software-use.json.gz") model_name = 'software_use' class_weights = None if use_ELMo: model_name += '-with_ELMo' elif use_BERT: model_name += '-with_BERT' batch_size, maxlen = configure(architecture, use_BERT, use_ELMo) model = Classifier(model_name, model_type=architecture, list_classes=list_classes, max_epoch=100, fold_number=fold_count, patience=10, use_roc_auc=True, embeddings_name=embeddings_name, use_ELMo=use_ELMo, use_BERT=use_BERT, batch_size=batch_size, maxlen=maxlen, class_weights=class_weights) if fold_count == 1: model.train(xtr, y) else: model.train_nfold(xtr, y) # saving the model model.save()
def train_and_eval_secondary(embeddings_name, fold_count, use_ELMo=False, use_BERT=False, architecture="gru"): print('training second-level dataset subtype corpus...') xtr, y1, y2, _, list_classes, list_subclasses, _ = load_dataseer_corpus_csv( "data/textClassification/dataseer/all-1.csv") # aggregate by class, we will have one training set per class print(list_classes) print(list_subclasses) print(len(list_classes), "classes") print(len(list_subclasses), "sub-classes") class_weights = None batch_size = 256 maxlen = 300 if use_ELMo: batch_size = 20 elif use_BERT: batch_size = 50 # default bert model parameters if architecture.find("bert") != -1: batch_size = 32 maxlen = 100 datatypes_y = {} datatypes_xtr = {} datatypes_list_subclasses = {} for i in range(0, len(xtr)): #print(np.where(y2[i] == 1)) ind1 = np.where(y1[i] == 1)[0][0] ind2 = np.where(y2[i] == 1)[0][0] #print(ind2) datatype = list_classes[ind1] datasubtype = list_subclasses[ind2] #print(str(xtr[i]), datatype, datasubtype) if datatype in datatypes_y: datatypes_y[datatype].append(datasubtype) datatypes_xtr[datatype].append(xtr[i]) if not datasubtype in datatypes_list_subclasses[datatype]: datatypes_list_subclasses[datatype].append(datasubtype) else: datatypes_y[datatype] = [] datatypes_y[datatype].append(datasubtype) datatypes_xtr[datatype] = [] datatypes_xtr[datatype].append(xtr[i]) datatypes_list_subclasses[datatype] = [] datatypes_list_subclasses[datatype].append(datasubtype) print(datatypes_list_subclasses) for the_class in list_classes: print('\ntraining', the_class) if not the_class in datatypes_list_subclasses: print('no subclass for', the_class) continue if len(datatypes_list_subclasses[the_class]) <= 1: print('only one subclass for', the_class) continue if len(datatypes_list_subclasses[the_class] ) == 2 and 'nan' in datatypes_list_subclasses[the_class]: continue if the_class == 'Protein Data': continue print('subtypes to be classified:', datatypes_list_subclasses[the_class]) model_name = 'dataseer-' + the_class if use_ELMo: model_name += '-with_ELMo' elif use_BERT: model_name += '-with_BERT' model = Classifier(model_name, model_type=architecture, list_classes=datatypes_list_subclasses[the_class], max_epoch=100, fold_number=fold_count, patience=10, use_roc_auc=True, embeddings_name=embeddings_name, use_ELMo=use_ELMo, use_BERT=use_BERT, batch_size=batch_size, maxlen=maxlen, class_weights=class_weights) # we need to vectorize the y according to the actual list of classes local_y = [] for the_y in datatypes_y[the_class]: the_ind = datatypes_list_subclasses[the_class].index(the_y) local_y.append( vectorizer(the_ind, len(datatypes_list_subclasses[the_class]))) # segment train and eval sets x_train, y_train, x_test, y_test = split_data_and_labels( np.asarray(datatypes_xtr[the_class]), np.asarray(local_y), 0.9) if fold_count == 1: model.train(x_train, y_train) else: model.train_nfold(x_train, y_train) model.eval(x_test, y_test)
def train(embeddings_name, fold_count, architecture="gru", transformer=None, cascaded=False): print('loading binary dataset type corpus...') xtr, y, _, _, list_classes, _, _ = load_dataseer_corpus_csv( "data/textClassification/dataseer/all-binary.csv") model_name = 'dataseer-binary_' + architecture class_weights = None batch_size, maxlen, patience, early_stop, max_epoch = configure( architecture) model = Classifier(model_name, architecture=architecture, list_classes=list_classes, max_epoch=max_epoch, fold_number=fold_count, use_roc_auc=True, embeddings_name=embeddings_name, batch_size=batch_size, maxlen=maxlen, patience=patience, early_stop=early_stop, class_weights=class_weights, transformer_name=transformer) if fold_count == 1: model.train(xtr, y) else: model.train_nfold(xtr, y) # saving the model model.save() print('loading reuse dataset type corpus...') xtr, y, _, _, list_classes, _, _ = load_dataseer_corpus_csv( "data/textClassification/dataseer/all-reuse.csv") model_name = 'dataseer-reuse_' + architecture class_weights = {0: 1.5, 1: 1.} model = Classifier(model_name, architecture=architecture, list_classes=list_classes, max_epoch=max_epoch, fold_number=fold_count, use_roc_auc=True, embeddings_name=embeddings_name, batch_size=batch_size, maxlen=maxlen, patience=patience, early_stop=early_stop, class_weights=class_weights, transformer_name=transformer) if fold_count == 1: model.train(xtr, y) else: model.train_nfold(xtr, y) # saving the model model.save() print('loading first-level dataset type corpus...') xtr, y, _, _, list_classes, _, _ = load_dataseer_corpus_csv( "data/textClassification/dataseer/all-multilevel.csv") model_name = 'dataseer-first_' + architecture class_weights = None model = Classifier(model_name, architecture=architecture, list_classes=list_classes, max_epoch=max_epoch, fold_number=fold_count, use_roc_auc=True, embeddings_name=embeddings_name, batch_size=batch_size, maxlen=maxlen, patience=patience, early_stop=early_stop, class_weights=class_weights, transformer_name=transformer) if fold_count == 1: model.train(xtr, y) else: model.train_nfold(xtr, y) # saving the model model.save() '''
def train_and_eval_secondary(embeddings_name, fold_count, architecture="gru", transformer=None): print('training second-level dataset subtype corpus...') xtr, y1, y2, _, list_classes, list_subclasses, _ = load_dataseer_corpus_csv( "data/textClassification/dataseer/all-multilevel.csv") # aggregate by class, we will have one training set per class print(list_classes) print(list_subclasses) print(len(list_classes), "classes") print(len(list_subclasses), "sub-classes") class_weights = None batch_size, maxlen, patience, early_stop, max_epoch = configure( architecture) datatypes_y = {} datatypes_xtr = {} datatypes_list_subclasses = {} for i in range(0, len(xtr)): #print(np.where(y2[i] == 1)) ind1 = np.where(y1[i] == 1)[0][0] ind2 = np.where(y2[i] == 1)[0][0] #print(ind2) datatype = list_classes[ind1] datasubtype = list_subclasses[ind2] #print(str(xtr[i]), datatype, datasubtype) if datatype in datatypes_y: datatypes_y[datatype].append(datasubtype) datatypes_xtr[datatype].append(xtr[i]) if not datasubtype in datatypes_list_subclasses[datatype]: datatypes_list_subclasses[datatype].append(datasubtype) else: datatypes_y[datatype] = [] datatypes_y[datatype].append(datasubtype) datatypes_xtr[datatype] = [] datatypes_xtr[datatype].append(xtr[i]) datatypes_list_subclasses[datatype] = [] datatypes_list_subclasses[datatype].append(datasubtype) print(datatypes_list_subclasses) for the_class in list_classes: print('\ntraining', the_class) if not the_class in datatypes_list_subclasses: print('no subclass for', the_class) continue if len(datatypes_list_subclasses[the_class]) <= 1: print('only one subclass for', the_class) continue if len(datatypes_list_subclasses[the_class] ) == 2 and 'nan' in datatypes_list_subclasses[the_class]: continue if the_class == 'Protein Data': continue print('subtypes to be classified:', datatypes_list_subclasses[the_class]) model_name = 'dataseer-' + the_class + "_" + architecture model = Classifier(model_name, architecture=architecture, list_classes=datatypes_list_subclasses[the_class], max_epoch=max_epoch, fold_number=fold_count, use_roc_auc=True, embeddings_name=embeddings_name, batch_size=batch_size, maxlen=maxlen, patience=patience, early_stop=early_stop, class_weights=class_weights, transformer_name=transformer) # we need to vectorize the y according to the actual list of classes local_y = [] for the_y in datatypes_y[the_class]: the_ind = datatypes_list_subclasses[the_class].index(the_y) local_y.append( vectorizer(the_ind, len(datatypes_list_subclasses[the_class]))) # segment train and eval sets x_train, y_train, x_test, y_test = split_data_and_labels( np.asarray(datatypes_xtr[the_class]), np.asarray(local_y), 0.9) if fold_count == 1: model.train(x_train, y_train) else: model.train_nfold(x_train, y_train) model.eval(x_test, y_test) # saving the model model.save()
def train(embeddings_name, fold_count, use_ELMo=False, use_BERT=False, architecture="gru", cascaded=False): print('loading binary dataset type corpus...') xtr, y, _, _, list_classes, _, _ = load_dataseer_corpus_csv( "data/textClassification/dataseer/all-binary.csv") model_name = 'dataseer-binary' class_weights = None batch_size = 256 maxlen = 300 if use_ELMo: batch_size = 20 model_name += '-with_ELMo' elif use_BERT: batch_size = 50 model_name += '-with_BERT' # default bert model parameters if architecture.lower().find("bert") != -1: batch_size = 32 maxlen = 100 model = Classifier(model_name, model_type=architecture, list_classes=list_classes, max_epoch=100, fold_number=fold_count, patience=10, use_roc_auc=True, embeddings_name=embeddings_name, use_ELMo=use_ELMo, use_BERT=use_BERT, batch_size=batch_size, maxlen=maxlen, class_weights=class_weights) if fold_count == 1: model.train(xtr, y) else: model.train_nfold(xtr, y) # saving the model model.save() print('loading reuse dataset type corpus...') xtr, y, _, _, list_classes, _, _ = load_dataseer_corpus_csv( "data/textClassification/dataseer/all-reuse.csv") model_name = 'dataseer-reuse' class_weights = None batch_size = 256 maxlen = 300 if use_ELMo: batch_size = 20 model_name += '-with_ELMo' elif use_BERT: batch_size = 50 model_name += '-with_BERT' # default bert model parameters if architecture.lower().find("bert") != -1: batch_size = 32 maxlen = 100 model = Classifier(model_name, model_type=architecture, list_classes=list_classes, max_epoch=100, fold_number=fold_count, patience=10, use_roc_auc=True, embeddings_name=embeddings_name, use_ELMo=use_ELMo, use_BERT=use_BERT, batch_size=batch_size, maxlen=maxlen, class_weights=class_weights) if fold_count == 1: model.train(xtr, y) else: model.train_nfold(xtr, y) # saving the model model.save() print('loading first-level dataset type corpus...') xtr, y, _, _, list_classes, _, _ = load_dataseer_corpus_csv( "data/textClassification/dataseer/all-1.csv") model_name = 'dataseer-first' if use_ELMo: model_name += '-with_ELMo' elif use_BERT: model_name += '-with_BERT' model = Classifier(model_name, model_type=architecture, list_classes=list_classes, max_epoch=100, fold_number=fold_count, patience=10, use_roc_auc=True, embeddings_name=embeddings_name, use_ELMo=use_ELMo, use_BERT=use_BERT, batch_size=batch_size, maxlen=maxlen, class_weights=class_weights) if fold_count == 1: model.train(xtr, y) else: model.train_nfold(xtr, y) # saving the model model.save() '''
def train_eval_cascaded(embeddings_name, fold_count, use_ELMo=False, use_BERT=False, architecture="gru"): # general setting of parameters class_weights = None batch_size = 256 maxlen = 300 if use_ELMo: batch_size = 20 elif use_BERT: batch_size = 50 # default bert model parameters if architecture.find("bert") != -1: batch_size = 32 maxlen = 100 # first binary classifier: dataset or no_dataset xtr, y, _, _, list_classes, _, _ = load_dataseer_corpus_csv( "data/textClassification/dataseer/all-binary.csv") print(list_classes) model_binary = Classifier('dataseer-binary', model_type=architecture, list_classes=list_classes, max_epoch=100, fold_number=fold_count, patience=10, use_roc_auc=True, embeddings_name=embeddings_name, use_ELMo=use_ELMo, use_BERT=use_BERT, batch_size=batch_size, maxlen=maxlen, class_weights=class_weights) # segment train and eval sets x_train, y_train, x_test, y_test = split_data_and_labels(xtr, y, 0.9) if fold_count == 1: model_binary.train(x_train, y_train) else: model_binary.train_nfold(x_train, y_train) model_binary.eval(x_test, y_test) x_test_binary = x_test y_test_binary = y_test # second, the first level datatype taxonomy for sentences classified as dataset xtr, y_classes, y_subclasses, y_leafclasses, list_classes, list_subclasses, list_leaf_classes = load_dataseer_corpus_csv( "data/textClassification/dataseer/all-1.csv") # ignore the no_dataset, ignore the first eval set, build first level classifier ind = list_classes.index('no_dataset') to_remove = vectorizer(ind, len(list_classes)) x_train, y_train = filter_exclude_class(xtr, y_classes, to_remove) y_train2 = np.zeros(shape=(len(y_train), len(list_classes) - 1)) for i in range(0, len(y_train)): y_train2[i] = np.delete(y_train[i], ind) y_train = y_train2 list_classes.remove('no_dataset') model_first = Classifier('dataseer-first', model_type=architecture, list_classes=list_classes, max_epoch=100, fold_number=fold_count, patience=10, use_roc_auc=True, embeddings_name=embeddings_name, use_ELMo=use_ELMo, use_BERT=use_BERT, batch_size=batch_size, maxlen=maxlen, class_weights=class_weights) if fold_count == 1: model_first.train(x_train, y_train) else: model_first.train_nfold(x_train, y_train) model_first.eval(x_test, y_test) # eval by cascading result_binary = model_binary.predict(x_test_binary, output_format='default') result_first = model_first.predict(x_test, output_format='default') # select sequences classified as dataset result_intermediate = np.asarray( [np.argmax(line) for line in result_binary]) def vectorize(index, size): result = np.zeros(size) if index < size: result[index] = 1 return result result_binary = np.array( [vectorize(xi, len(list_classes)) for xi in result_intermediate])