trainLabelsFile = 'H:/Documents/Datasets/Hands2017/Cropped/trainLabelCropped.csv' trainImagesFolder = 'H:/Documents/Datasets/Hands2017/Cropped/train/' testLabelsFile = 'H:/Documents/Datasets/Hands2017/Cropped/testLabelCropped.csv' testImagesFolder = 'H:/Documents/Datasets/Hands2017/Cropped/test/' cropSize = 176 def preprocess(image): mark = image[0, 0].copy() image[0, 0] = (image[0, 1] + image[1, 0]) / 2. image = image - mark image = image / 255. return image datagen = ImageDataGenerator(preprocessing_function=preprocess) # validation_split=0.10) features = [ "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12", "F13", "F14", "F15", "F16", "F17", "F18", "F19", "F20", "F21", "F22", "F23", "F24", "F25", "F26", "F27", "F28", "F29", "F30", "F31", "F32", "F33", "F34", "F35", "F36", "F37", "F38", "F39", "F40", "F41", "F42", "F43", "F44", "F45", "F46", "F47", "F48", "F49", "F50", "F51", "F52", "F53", "F54", "F55", "F56", "F57", "F58", "F59", "F60", "F61", "F62", "F63" ] def GetGenerators(): traindf = pd.read_csv(trainLabelsFile, dtype=str) # load and iterate training dataset train_generator = datagen.flow_from_dataframe(
model = Model(inputs=vgg16_model.input, outputs=preds) model.summary() for i, layer in enumerate(model.layers): print(i, layer.name) for layer in model.layers[:19]: layer.trainable = False for layer in model.layers[19:]: layer.trainable = True for i, layer in enumerate(model.layers): print(i, " " + layer.name, layer.trainable) train_datagen = ImageDataGenerator(preprocessing_function=preprocess_input) validate_datagen = ImageDataGenerator(preprocessing_function=preprocess_input) train_generator = train_datagen.flow_from_directory(directory=r"./train/", target_size=(300, 300), color_mode="rgb", batch_size=4, class_mode="binary", shuffle=True, seed=42) validate_generator = validate_datagen.flow_from_directory( directory=r"./validate/", target_size=(300, 300), color_mode="rgb", batch_size=4,
log = logging.getLogger(__name__) log.info("Tensorflow version: %s" % tf.__version__) img_width = 500 img_height = 500 if K.image_data_format() == 'channels_first': input_shape = (3, img_width, img_height) else: input_shape = (img_width, img_height, 3) log.info("loading train batches...") train_batches = ImageDataGenerator().flow_from_directory( directory=os.path.join(RESOURCES_DIR, "batches", "train"), target_size=(img_width, img_height), class_mode="binary", batch_size=1) log.info("loading test batches...") test_batches = ImageDataGenerator().flow_from_directory( directory=os.path.join(RESOURCES_DIR, "batches", "test"), target_size=(img_width, img_height), class_mode="binary", batch_size=1) print(train_batches.labels) print(train_batches.filenames) model = keras.Sequential([ keras.layers.Flatten(input_shape=input_shape), keras.layers.Dense(128, activation='relu'),
X = it1.next() Y = it2.next() yield X,Y # Define our custom metric def PSNR(y_true, y_pred): max_pixel = 1.0 return 10.0 * (1.0 / math.log(10)) * K.log((max_pixel ** 2) / (K.mean(K.square(y_pred - y_true)))) # parameters epochs = int(sys.argv[1]) batch_size = int(sys.argv[2]) # Create generator datagen = ImageDataGenerator(validation_split=0.1, rescale=1./255) # Prepare training and validation datasets train_it = datagen.flow_from_directory(directory='data/big/', target_size=(200,80), shuffle=False, color_mode='grayscale', class_mode=None, batch_size=batch_size, subset='training') val_it = datagen.flow_from_directory(directory='data/big/', target_size=(200,80), shuffle=False, color_mode='grayscale', class_mode=None, batch_size=batch_size, subset='validation') train_small_it = datagen.flow_from_directory(directory='data/small/', target_size=(100,40), shuffle=False, color_mode='grayscale', class_mode=None, batch_size=batch_size, subset='training') val_small_it = datagen.flow_from_directory(directory='data/small/', target_size=(100,40), shuffle=False, color_mode='grayscale', class_mode=None, batch_size=batch_size, subset='validation') # Build model input_img = Input(shape=(100, 40, 1)) # adapt this if using `channels_first` image data format x = UpSampling2D((2, 2), interpolation='bilinear')(input_img) upsample = Model(input_img, x) upsample.compile(optimizer='adadelta', loss='mean_squared_error', metrics=[PSNR]) # Train
spc = config_vals['spc'] ep = config_vals['ep'] print("steps per epoch = "+ str(spc)) print("epochs = "+ str(ep)) config_vals['spc'] = spc + 100 config_vals['ep'] = ep + 1 with open("config.yaml", "w") as cw: yaml.dump(config_vals, cw, default_flow_style=True) train_datagen = ImageDataGenerator( rescale=1./255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) test_datagen = ImageDataGenerator(rescale=1./255) train_dataset = train_datagen.flow_from_directory( '/covid_folder/xray_dataset_covid19/train/', target_size=(64,64), batch_size=32, class_mode='binary') test_dataset = test_datagen.flow_from_directory( '/covid_folder/xray_dataset_covid19/test/', target_size=(64,64), batch_size=32, class_mode='binary') working=model.fit( train_dataset,
def Learn(augmentation, input_epochs, train_path, val_path, window): #path BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) train_dir = os.path.join(BASE_DIR, train_path) val_dir = os.path.join(BASE_DIR, val_path) print(train_dir) print(val_dir) # Define hyperparameter INPUT_SIZE = 200 CHANNELS = 3 INPUT_SHAPE = (INPUT_SIZE, INPUT_SIZE, CHANNELS) NUM_CLASSES = window.learn_num_data[0] NUM_TRAIN_IMGS = window.learn_num_data[1] * NUM_CLASSES NUM_VAL_IMGS = window.learn_num_data[2] * NUM_CLASSES BATCH_SIZE = 32 HORIZONTAL_FLIP = augmentation[0] VERTICAL_FLIP = augmentation[1] BRIGHTNESS_RANGE = augmentation[2] ROTATION_RANGE = augmentation[3] if augmentation[4] == True: CUT_OUT = cutout(p=0.5, s_l=0.02, s_h=0.4, r_1=0.3, r_2=1 / 0.3, pixel_level=False) else: CUT_OUT = None EPOCHS = input_epochs train_steps_per_epoch = NUM_TRAIN_IMGS // BATCH_SIZE val_steps_per_epoch = NUM_VAL_IMGS // BATCH_SIZE # Data Preprocessing training_datagen = ImageDataGenerator( rescale=1. / 255, horizontal_flip=HORIZONTAL_FLIP, vertical_flip=VERTICAL_FLIP, brightness_range=BRIGHTNESS_RANGE, rotation_range=ROTATION_RANGE, preprocessing_function=CUT_OUT, ) validation_datagen = ImageDataGenerator(rescale=1. / 255) train_generator = training_datagen.flow_from_directory( train_dir, target_size=(INPUT_SIZE, INPUT_SIZE), class_mode='categorical', batch_size=BATCH_SIZE) validation_generator = validation_datagen.flow_from_directory( val_dir, target_size=(INPUT_SIZE, INPUT_SIZE), class_mode='categorical', batch_size=BATCH_SIZE) # Load pre-trained model base_model = tf.keras.applications.VGG16( include_top=False, weights='imagenet', input_shape=INPUT_SHAPE, ) # Freeze the pre-trained layers base_model.trainable = False # Add a fully connected layer model = tf.keras.Sequential() model.add(base_model) model.add(tf.keras.layers.Flatten()) model.add(tf.keras.layers.Dense(512, activation='relu')) model.add(tf.keras.layers.Dropout(0.5)) model.add(tf.keras.layers.Dense(256, activation='relu')) model.add(tf.keras.layers.Dropout(0.5)) model.add(tf.keras.layers.Dense(NUM_CLASSES, activation='softmax')) model.summary() # Compile model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) # Callbacks checkpoint_filepath = os.path.join( BASE_DIR, 'checkpoint', window.settingsData[0] + '_' + window.settingsData[3] + '.h5') plotLosses = PlotLosses(input_epochs, window) callbacks = [ tf.keras.callbacks.EarlyStopping( patience=10, monitor='val_loss', # restore_best_weights=True ), tf.keras.callbacks.ModelCheckpoint( filepath=checkpoint_filepath, monitor='val_loss', mode='min', save_best_only=True, # save_weights_only=True, ), plotLosses, ] # training model history = model.fit(train_generator, epochs=EPOCHS, steps_per_epoch=train_steps_per_epoch, validation_data=validation_generator, validation_steps=val_steps_per_epoch, verbose=1, callbacks=callbacks) window.textBox_terminal.append("Training Done!") val_loss = history.history['val_loss'] val_accuracy = history.history['val_accuracy'] max_val_accuracy = round(np.max(val_accuracy), 4) min_val_loss = round(np.min(val_loss), 4) message = "Epoch: " + str(np.argmin(val_loss) + 1) + " , Min val_loss: " + str(min_val_loss) window.textBox_terminal.append(message) window.settingsData.append(min_val_loss) window.settingsData.append(max_val_accuracy) plt.close()
def predict_on_test(self): """ This function will load the test dataset, pre-process the test images and check the performance of the trained models on unseen data. This will also save the confusion matrix and classification report as csv file in seperate dataframes for each model and for each stage, in the evaluation directory. Arguments: -size_dict : Contains information about the image input image sizes for each of the models -model_name : Name of the model, for example - vgg16, inception_v3, resnet50 etc -stage_no : The training stage of the model. You will have a choice to select the number of training stages. In stage 1, we only fine tune the top 2 dense layers by freezing the convolution base. In stage 2, we will re adjust the weights trained in stage 1 by training the top convolution layers, by freezing the dense layers. """ print("\nStarting model evaluation for stage {}..".format( self.stage_no)) #Create an utility class object to access the class methods utils_obj = Utility(self.input_params, self.path_dict) df_test = utils_obj.load_data("test") test_datagen = ImageDataGenerator( preprocessing_function=utils_obj.init_preprocess_func()) test_generator = test_datagen.flow_from_dataframe( dataframe=df_test, directory=self.path_dict['source'], target_size=utils_obj.init_sizes(), x_col="filenames", y_col="class_label", batch_size=1, class_mode='categorical', color_mode='rgb', shuffle=False) nb_test_samples = len(test_generator.classes) model = utils_obj.get_models(self.stage_no) class_indices = test_generator.class_indices def label_class(cat_name): return (class_indices[cat_name]) df_test['true'] = df_test['class_label'].apply( lambda x: label_class(str(x))) y_true = df_test['true'].values #Predictions (Probability Scores and Class labels) y_pred_proba = model.predict_generator(test_generator, nb_test_samples // 1) y_pred = np.argmax(y_pred_proba, axis=1) df_test['predicted'] = y_pred df_test.to_csv(self.path_dict["eval_path"] + "stage{}/".format(self.stage_no) + '{}_predictions_stage_{}.csv'.format( self.input_params['model_name'], self.stage_no)) dictionary = dict(zip(df_test.true.values, df_test.class_label.values)) #Confusion Matrixs cm = metrics.confusion_matrix(y_true, y_pred) df_cm = pd.DataFrame(cm).transpose() df_cm = df_cm.rename(mapper=dict, index=dictionary, columns=dictionary, copy=True, inplace=False) df_cm.to_csv(self.path_dict["eval_path"] + "stage{}/".format(self.stage_no) + '{}_cm_stage_{}.csv'.format( self.input_params['model_name'], self.stage_no)) print('Confusion matrix prepared and saved..') #Classification Report report = metrics.classification_report(y_true, y_pred, target_names=list( class_indices.keys()), output_dict=True) df_rep = pd.DataFrame(report).transpose() df_rep.to_csv(self.path_dict["eval_path"] + "stage{}/".format(self.stage_no) + '{}_class_report_stage_{}.csv'.format( self.input_params['model_name'], self.stage_no)) print('Classification report prepared and saved..') EvalUtils.plot_confusion_matrix( self, y_true, y_pred, list(test_generator.class_indices.keys())) #General Metrics df_metrics = EvalUtils.get_metrics(self, y_true, y_pred) df_metrics.to_csv(self.path_dict["eval_path"] + "stage{}/".format(self.stage_no) + '{}_metrics_stage_{}.csv'.format( self.input_params['model_name'], self.stage_no)) history_df = pd.read_csv( self.path_dict["model_path"] + "stage{}/".format(self.stage_no) + "{}_history_stage_{}.csv".format(self.input_params['model_name'], self.stage_no)) #Get the train vs validation loss for all epochs EvalUtils.plt_epoch_error(self, history_df) #Generate a complete report and save it as an HTML file in the evaluation folder location EvalUtils.get_complete_report(self, y_true, y_pred, class_indices)
def memory_managing(): print('Using Keras version', keras.__version__) train_datagen = ImageDataGenerator(samplewise_center=True, samplewise_std_normalization=True, width_shift_range=0.2, height_shift_range=0.2, channel_shift_range=30, rescale=1. / 255) valid_datagen = ImageDataGenerator(samplewise_center=True, samplewise_std_normalization=True, width_shift_range=0.2, height_shift_range=0.2, channel_shift_range=30, rescale=1. / 255) test_datagen = ImageDataGenerator(samplewise_center=True, samplewise_std_normalization=True, width_shift_range=0.2, height_shift_range=0.2, channel_shift_range=30, rescale=1. / 255) train_generator = train_datagen.flow_from_directory( directory="food11re/training/", target_size=(200, 200), color_mode="rgb", batch_size=120, class_mode="categorical", shuffle=True, seed=25) valid_generator = valid_datagen.flow_from_directory( directory="food11re/validation/", target_size=(200, 200), color_mode="rgb", batch_size=120, class_mode="categorical", shuffle=True, seed=25) test_generator = test_datagen.flow_from_directory( directory="food11re/evaluation/", target_size=(200, 200), color_mode="rgb", batch_size=120, class_mode=None, shuffle=True, seed=25) input_size = (200, 200, 3) model = cnn_architecture(input_size) # model= using_already_trained_models(input_size) opt = optimizers.Adam() sgd = optimizers.SGD(lr=0.001, momentum=0.9, nesterov=True) model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy']) train_size = train_generator.n // train_generator.batch_size valid_size = valid_generator.n // valid_generator.batch_size checkpointer = ModelCheckpoint( filepath='./first.3.{epoch:02d}-{val_loss:.2f}.hdf5', verbose=1, save_best_only=True) history = model.fit_generator(generator=train_generator, steps_per_epoch=train_size, validation_data=valid_generator, validation_steps=valid_size, epochs=80, callbacks=[checkpointer]) accuracy_loss_plots(history) score = model.evaluate_generator(generator=valid_generator, steps=len(valid_generator)) print('test loss:', score[0]) print('test accuracy:', score[1]) test_generator.reset() Y_pred = model.predict_generator(test_generator, steps=len(test_generator), verbose=1) y_pred = np.argmax(Y_pred, axis=1) labels = train_generator.class_indices labels = dict((v, k) for k, v in labels.items()) predictions = [labels[k] for k in y_pred] print('Confusion Matrix') confusion_m = confusion_matrix(test_generator.classes, y_pred) print(confusion_m) print('Classification Report') target_names = [ 'Bread', 'Dairy_product', 'Dessert', 'Egg', 'Fried_food', 'Meat', 'Noodles', 'Rice', 'Seafood', 'Soup', 'Veggies' ] print( classification_report(test_generator.classes, y_pred, target_names=target_names)) plot_confusion_matrix(confusion_m, target_names) print("finished")
metrics=['accuracy']) if not data_augmentation: print('Not using data augmentation.') model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(x_val, y_val), shuffle=False) else: print('Using real-time data augmentation.') datagen = ImageDataGenerator(rotation_range=30, zoom_range=0.20, width_shift_range=0.25, height_shift_range=0.25, shear_range=0.20, horizontal_flip=True, fill_mode="nearest") # Fit the model on the batches generated by datagen.flow(). history = model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size), epochs=epochs, validation_data=(x_val, y_val)) scores = model.evaluate(x_test, y_test) print(scores) pd.DataFrame(history.history).plot(figsize=(8, 5))
def train_model(save_mode=False, model_name="NaN"): num_classes = 7 #angry, disgust, fear, happy, sad, surprise, neutral batch_size = 64 epochs = 1000 dataset = fer2013(DATASET_PATH, val_ratio=0.05) dataset.reshape_size(IMG_SIZE) X_train = dataset.X_train Y_train = dataset.Y_train X_val = dataset.X_val Y_val = dataset.Y_val X_test = dataset.X_test Y_test = dataset.Y_test model = demo_CNN_model(input_size=(IMG_SIZE, IMG_SIZE, 1)) # generators are used to handle large quanteties of data, important form machine learning train_generator = ImageDataGenerator().flow(X_train, Y_train, batch_size=batch_size) validation_generator = ImageDataGenerator().flow(X_val, Y_val, batch_size=batch_size) early_stopping_monitor = callbacks.EarlyStopping(monitor='val_loss', patience=7, verbose=1, mode='auto') checkpointer = callbacks.ModelCheckpoint( filepath="saved_models/model_weight.h5", verbose=1, save_best_only=True) sgd = optimizers.SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit_generator(generator=train_generator, validation_data=validation_generator, callbacks=[early_stopping_monitor, checkpointer], steps_per_epoch=batch_size, epochs=epochs) # ------------- evaluate the model-------------- train_score = model.evaluate(X_train, Y_train, verbose=0) print('Train loss:', train_score[0]) print('Train accuracy:', 100 * train_score[1]) test_score = model.evaluate(X_test, Y_test, verbose=0) print('Test loss:', test_score[0]) print('Test accuracy:', 100 * test_score[1]) # -------------------save model------------------ if save_mode: model_json = model.to_json() with open("saved_models/model_graph.json", "w") as json_file: json_file.write(model_json) # serialize weights to HDF5 # model.save_weights("saved_models/model_weight.h5") print("Saved model to disk") return model
classifier.add(Dropout(0.5)) classifier.add(Dense(150, activation='relu')) #classifier.add(Dropout(0.5)) classifier.add(Dense(1, activation='linear')) #Adding full connection layer increases the parameter size. return classifier # Part 2 - Fitting the CNN to the images from keras_preprocessing.image import ImageDataGenerator from PIL import Image train_datagen = ImageDataGenerator(rescale=1. / 255., featurewise_std_normalization=True, validation_split=0.20) test_datagen = ImageDataGenerator(rescale=1. / 255.) training_set = train_datagen.flow_from_dataframe(dataframe=train_dataset, directory='./data/training/', x_col='image_names', y_col='labels', subset="training", class_mode="other", target_size=(480, 480), batch_size=30, shuffle=True) validation_set = train_datagen.flow_from_dataframe( dataframe=train_dataset,
callbacks = EarlyStopping(monitor='val_loss', patience=1, verbose=1, mode='auto') # autosave best Model best_model_file = "data_augmented_weights.h5" best_model = ModelCheckpoint(best_model_file, monitor='val_acc', verbose=2, save_best_only=True) # In[16]: train_datagen = ImageDataGenerator(shear_range=0.1, zoom_range=0.1, rotation_range=10., width_shift_range=0.1, height_shift_range=0.1, horizontal_flip=True) val_datagen = ImageDataGenerator() history = vgg16_model.fit_generator(train_datagen.flow(X_train, Y_train, batch_size=batch_size), nb_epoch=epochs, samples_per_epoch=len(X_train), validation_data=val_datagen.flow( X_test, Y_test, batch_size=64, shuffle=False),
from tensorflow.python.client import device_lib print("Num GPUs Available: ", len(tf.config.list_physical_devices('GPU'))) device_lib.list_local_devices() # DATA INPUT ------------------------------------------------# data_dictionary_location = 'C://Users//jbolton//Documents//naughty//deep_tagger//data_dictionary.csv' images_location = 'C://Users//jbolton//Documents//naughty//deep_tagger//images//' data_dict_df = pd.read_csv(data_dictionary_location) label_colnames = list(data_dict_df.columns[1:]) train_data_gen = ImageDataGenerator( # rotation_range = 40 #, width_shift_range = 0.2 #, height_shift_range = 0.2 #, shear_range = 0.2 #, zoom_range = 0.2 #, horizontal_flip = True #, fill_mode = 'nearest' ) valid_test_data_gen = ImageDataGenerator() # here is some code showing an example of what the image augmentation is doing: my_img = load_img( 'C://Users//jbolton//Documents//naughty//deep_tagger//images//prod_35.png') my_img = img_to_array(my_img) my_img = my_img.reshape((1, ) + my_img.shape) i = 0 for batch_i in train_data_gen.flow(my_img, batch_size=1): array_to_img(batch_i[0]).show()
def generate_backdoor( self, x_val: np.ndarray, y_val: np.ndarray, y_target: np.ndarray) -> Tuple[np.ndarray, np.ndarray]: """ Generates a possible backdoor for the model. Returns the pattern and the mask :return: A tuple of the pattern and mask for the model. """ import keras.backend as K from keras_preprocessing.image import ImageDataGenerator self.reset() datagen = ImageDataGenerator() gen = datagen.flow(x_val, y_val, batch_size=self.batch_size) mask_best: Optional[np.ndarray] = None pattern_best: Optional[np.ndarray] = None reg_best = float("inf") cost_set_counter = 0 cost_up_counter = 0 cost_down_counter = 0 cost_up_flag = False cost_down_flag = False early_stop_counter = 0 early_stop_reg_best = reg_best mini_batch_size = len(x_val) // self.batch_size for _ in tqdm( range(self.steps), desc=f"Generating backdoor for class {np.argmax(y_target)}"): loss_reg_list = [] loss_acc_list = [] for _ in range(mini_batch_size): x_batch, _ = gen.next() y_batch = [y_target] * x_batch.shape[0] _, batch_loss_reg, _, batch_loss_acc = self.train( [x_batch, y_batch]) loss_reg_list.extend(list(batch_loss_reg.flatten())) loss_acc_list.extend(list(batch_loss_acc.flatten())) avg_loss_reg = np.mean(loss_reg_list) avg_loss_acc = np.mean(loss_acc_list) # save best mask/pattern so far if avg_loss_acc >= self.attack_success_threshold and avg_loss_reg < reg_best: mask_best = K.eval(self.mask_tensor) pattern_best = K.eval(self.pattern_tensor) reg_best = avg_loss_reg # check early stop if self.early_stop: # pragma: no cover if reg_best < float("inf"): if reg_best >= self.early_stop_threshold * early_stop_reg_best: early_stop_counter += 1 else: early_stop_counter = 0 early_stop_reg_best = min(reg_best, early_stop_reg_best) if cost_down_flag and cost_up_flag and early_stop_counter >= self.early_stop_patience: logger.info("Early stop") break # cost modification if avg_loss_acc >= self.attack_success_threshold: cost_set_counter += 1 if cost_set_counter >= self.patience: self.cost = self.init_cost K.set_value(self.cost_tensor, self.cost) cost_up_counter = 0 cost_down_counter = 0 cost_up_flag = False cost_down_flag = False else: cost_set_counter = 0 if avg_loss_acc >= self.attack_success_threshold: cost_up_counter += 1 cost_down_counter = 0 else: cost_up_counter = 0 cost_down_counter += 1 if cost_up_counter >= self.patience: cost_up_counter = 0 self.cost *= self.cost_multiplier_up K.set_value(self.cost_tensor, self.cost) cost_up_flag = True elif cost_down_counter >= self.patience: cost_down_counter = 0 self.cost /= self.cost_multiplier_down K.set_value(self.cost_tensor, self.cost) cost_down_flag = True if mask_best is None: mask_best = K.eval(self.mask_tensor) pattern_best = K.eval(self.pattern_tensor) if pattern_best is None: raise ValueError("Unexpected `None` detected.") return mask_best, pattern_best
baseKernels = [] baseKernels.append((1, 4, 6, 4, 1)) baseKernels.append((1, -2, 0, -2, 1)) baseKernels.append((-1, 0, 2, 0, -1)) baseKernels.append((1, -4, 6, -4, 1)) baseKernels = np.array(baseKernels) #get directory of input images and create array of images and store images in the directory to the array train_dir = "C:/Users/panka/OneDrive/Desktop/Aditya/image data 2018-19/Train_Resized" #get labels pickle and convert to dataframe then sort by the filename to go along with the images train_labels_file = "C:/Users/panka/OneDrive/Desktop/Aditya/image data 2018-19/Training_Input_Resized.pkl" train_labels = pd.read_pickle(train_labels_file) train_datagen = ImageDataGenerator(rescale=1. / 255) train_generator = train_datagen.flow_from_dataframe( dataframe=train_labels, directory=train_dir, target_size=(108, 192), x_col='Filename', y_col=[ 'Right Ankle x', 'Right Knee x', 'Right Hip x', 'Left Hip x', 'Left Knee x', 'Left Ankle x', 'Pelvis x', 'Thorax x', 'Upper Neck x', 'Head Top x', 'Right Wrist x', 'Right Elbow x', 'Right Shoulder x', 'Left Shoulder x', 'Left Elbow x', 'Left Wrist x', 'Right Ankle y', 'Right Knee y', 'Right Hip y', 'Left Hip y', 'Left Knee y', 'Left Ankle y', 'Pelvis y', 'Thorax y', 'Upper Neck y', 'Head Top y', 'Right Wrist y', 'Right Elbow y', 'Right Shoulder y', 'Left Shoulder y', 'Left Elbow y', 'Left Wrist y' ],
import tensorflow as tf from keras.optimizers import RMSprop from keras_preprocessing.image import ImageDataGenerator import numpy as np from google.colab import files from keras_preprocessing import image train_datagen = ImageDataGenerator(rescale=1. / 255) train_generator = train_datagen.flow_from_directory(train_dir, target_size=(300, 300), batch_size=128, class_mode='binary') test_datagen = ImageDataGenerator(rescale=1. / 255) validation_generator = test_datagen.flow_from_directory(validation_dir, target_size=(300, 300), batch_size=32, class_mode='binary') model = tf.keras.models.Sequential([tf.keras.layers.Conv2D(16, (3, 3), activation='relu', input_shape=(300, 300, 3)), tf.keras.layers.MaxPooling2D(2, 2), tf.keras.layers.Conv2D(32, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), tf.keras.layers.Conv2D(64, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), tf.keras.layers.Flatten(), tf.keras.layers.Dense(512, activation='relu'), tf.keras.layers.Dense(1, activation='sigmoid') ])
for i, img_path in enumerate(next_rock + next_paper + next_scissors): # print(img_path) img = mpimg.imread(img_path) plt.imshow(img) plt.axis('Off') plt.show() # %% import tensorflow as tf import keras_preprocessing from keras_preprocessing import image from keras_preprocessing.image import ImageDataGenerator TRAINING_DIR = os.path.join(base_dir, "rps") training_datagen = ImageDataGenerator(rescale=1. / 255, rotation_range=0.2, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode='nearest') VALIDATION_DIR = os.path.join(base_dir, "rps-test-set") validation_datagen = ImageDataGenerator(rescale=1. / 255) train_generator = training_datagen.flow_from_directory(TRAINING_DIR, target_size=(150, 150), class_mode="categorical", batch_size=126)
def train(): ############### 1. Generating captchas images, labels = get_data_set(width=img_x, height=img_y, nr_of_chars=nr_of_chars, color=color, nr_of_captchas=numberOfCaptchas, number=numbers) ############### 2. Preprocessing the data # # Data needs to be reshaped into a 4D tensor - (sample_number, x_img_size, y_img_size, num_channels) # The number of channels = number of colors grescale = 1, color = 3 images_train = images[:testSize] print('Before reshaping, 3D :', images_train.shape) images_train = images_train.reshape(images_train.shape[0], img_x, img_y, depth) images_train = images_train.astype( 'float32') / 255 # Scaling color dimension to 0-255 to 0-1 print('After reshaping, 3D :', images_train[0].shape) images_test = images[testSize:] images_test = images_test.reshape(images_test.shape[0], img_x, img_y, depth) images_test = images_test.astype('float32') / 255 labels_train = labels[:testSize] labels_test = labels[testSize:] # The categories are characters [aa, ab, ac, ... ] categories = get_all_possible_label_categories(nr_of_chars, number=numbers) lb = LabelBinarizer().fit(categories) labels_encoded_train = lb.transform(labels_train) labels_encoded_test = lb.transform(labels_test) # Data generator for image augmentation datagen = ImageDataGenerator( rotation_range=10, #15 graden rotatie van image ) gen_train = datagen.flow(images_train, labels_encoded_train, batch_size=100) ############### 3. Building the neural network # Sequential model model = Sequential() # First conv: 32 filters of 3x3 model.add( Conv2D(16, (5, 5), padding='same', input_shape=(img_x, img_y, 1), activation="relu")) model.add(Dropout(0.3)) model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) # Second conv model.add(layers.Conv2D(32, (5, 5), padding='same', activation='relu')) model.add(Dropout(0.3)) model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) # Third conv model.add(layers.Conv2D(64, (5, 5), padding='same', activation='relu')) model.add(Dropout(0.3)) model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) # Fully connected layer model.add(Flatten()) model.add(Dense(512, activation="relu")) model.add(Dropout(0.5)) model.add(Dense(len(categories), activation="softmax")) print(model.summary()) model.compile(loss="categorical_crossentropy", optimizer=optimizers.Adam(), metrics=["accuracy"]) ############### 4. Training the neural network history = model.fit_generator( gen_train, validation_data=(images_test, labels_encoded_test), steps_per_epoch=40, #40 * 100 = 4000 == size trainingsdata epochs=80) ############### 5. Visualizing and saving the result # Retrieving the acc and loss acc = history.history['acc'] val_acc = history.history['val_acc'] loss = history.history['loss'] val_loss = history.history['val_loss'] # Creating the output dir for this model if not numbers: model_dir = os.path.join( output_dir, 'model_chars' + str(nr_of_chars) + '_acc_' + str(max(val_acc)).replace('.', '_')[:4]) else: model_dir = os.path.join( output_dir, 'model_nrs' + str(nr_of_chars) + '_acc_' + str(max(val_acc)).replace('.', '_')[:4]) if os.path.exists(model_dir): model_dir = os.path.join(model_dir, '_' + str(time.time())) os.mkdir(model_dir) model.save(os.path.join(model_dir, 'model.h5')) model_json = model.to_json() copyfile('./captcha_learner_1.py', os.path.join(model_dir, 'captcha_learner_1.py')) with open(os.path.join(model_dir, 'model.json'), "w") as json_file: json_file.write(model_json) epochs = range(1, len(acc) + 1) plt.figure() plt.subplot(211) plt.plot(epochs, acc, 'bo', label='Training acc') plt.plot(epochs, val_acc, 'b', label='Validation acc') plt.title('Training and validation accuracy') plt.legend() plt.subplot(212) plt.plot(epochs, loss, 'bo', label='Training loss') plt.plot(epochs, val_loss, 'b', label='Validation loss') plt.title('Training and validation loss') plt.legend() plt.savefig(os.path.join(model_dir, 'metrics.png')) plt.show()
from tensorflow.keras import layers from keras_preprocessing.image import ImageDataGenerator # This is the code that sets up the dataframes to give us our data generators train_dir = '/kaggle/input/siim-isic-melanoma-classification/jpeg/train/' test_dir = '/kaggle/input/siim-isic-melanoma-classification/jpeg/test/' df_train = pd.read_csv( '/kaggle/input/siim-isic-melanoma-classification/train.csv') df_test = pd.read_csv( '/kaggle/input/siim-isic-melanoma-classification/test.csv') df_train['image_num'] = df_train.apply( lambda row: train_dir + row['image_name'] + '.jpg', axis=1) df_test['image_num'] = df_test.apply( lambda row: test_dir + row['image_name'] + '.jpg', axis=1) datagen = ImageDataGenerator(rescale=1. / 255., validation_split=0.25) train_generator = datagen.flow_from_dataframe(dataframe=df_train, x_col="image_num", y_col="target", subset="training", batch_size=32, seed=42, shuffle=True, class_mode="raw", target_size=(224, 224)) valid_generator = datagen.flow_from_dataframe(dataframe=df_train, x_col="image_num", y_col="target", subset="validation",
'/home/shubrah/bird/REWB_1/338f25d0-afb1-42f9-9d66-98aa54af9348.wav', '/home/shubrah/bird/YEBB_1/23cc7059-ad02-4b7d-905a-edb8503d4f69.wav', '/home/shubrah/bird/INSB_1/1e526283-de1b-47f4-a6c8-1fad0fa5d714.wav', '/home/shubrah/bird/INSB_1/c9a731b0-699b-49c8-8b87-d48ad45d8288.wav', '/home/shubrah/bird/LABC_1/80404893-0cbb-42b3-b9c1-f95e069fa90a.wav', '/home/shubrah/bird/LABC_2/d244afaf-7fa4-4c34-8ee7-d69682d9c2f8.wav', '/home/shubrah/bird/GRTD_s/22ba0fdb-42d6-471f-ad57-603bfa139b1e.wav' ] for i in range(len(extract)): create_spectrogram(extract[i], extract[i].split('/')[5].split('.')[0]) traindf = create_df(extract, 'train') from keras_preprocessing.image import ImageDataGenerator datagen = ImageDataGenerator(rescale=1. / 255., validation_split=0.25) train_generator = datagen.flow_from_dataframe( dataframe=traindf, directory="/home/shubrah/ml/pad/train/", x_col="filename", y_col="class", subset="training", batch_size=32, seed=42, shuffle=True, class_mode="categorical", target_size=(64, 64)) valid_generator = datagen.flow_from_dataframe( dataframe=traindf,
'teenager', 'youth', 'middle_age', 'senior', 'white', 'black', 'asian', 'oval_face', 'round_face', 'heart_face', 'smiling', 'mouth_open', 'frowning', 'wearing_glasses', 'wearing_sunglasses', 'wearing_lipstick', 'tongue_out', 'duck_face', 'black_hair', 'blond_hair', 'brown_hair', 'red_hair', 'curly_hair', 'straight_hair', 'braid_hair', 'showing_cellphone', 'using_earphone', 'using_mirror', 'braces', 'wearing_hat', 'harsh_lighting', 'dim_lighting' ] #Lendo o arquivo txt, separando ele por espacos e colocando num dicionario com o nome de cada atributo data = pd.read_csv(path + 'selfie_dataset.txt', header=None, sep=' ', names=names) train_datagen = ImageDataGenerator(rescale=1. / 255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) test_datagen = ImageDataGenerator(rescale=1. / 255) #aplicar a extensao da imagem def append_ext(fn): return fn + ".jpg" #substituir o score pelas classes (boa, neutra, ruim) def apply_class(fn): if fn > 4.7: return 'boa' elif fn > 3.5:
#loading the trained models model_fruit = load_model('models/fruits-classifier-model.h5', compile=False) model_orange = load_model("models/oranges-classifier-model.h5", compile=False) #setting the size to which the images will be resized and the batch size img_rows, img_cols = 32, 32 batch_size = 20 #getting the labels of the fruit classifier model train_dataset_fruit = 'datasets/fruits/fruits/Train' test_dataset_fruit = 'datasets/fruits/fruits/Test' train_data_fruit = ImageDataGenerator(rescale=1. / 255, rotation_range=30, width_shift_range=0.3, height_shift_range=0.3, horizontal_flip=True, fill_mode='nearest') train_generator_fruit = train_data_fruit.flow_from_directory( train_dataset_fruit, target_size=(img_rows, img_cols), batch_size=batch_size, class_mode='categorical', shuffle=True) test_data_fruit = ImageDataGenerator(rescale=1. / 255) test_generator = test_data_fruit.flow_from_directory(test_dataset_fruit, target_size=(img_rows, img_cols),
model.add(Flatten()) model.add( Dense(8, activation='relu', kernel_regularizer=regularizers.l2(0.5))) model.add(BatchNormalization()) model.add(Dropout(0.25)) model.add(Dense(3, activation='softmax')) # Show a summary of the model. Check the number of trainable parameters model.summary() train_dir = 'C:\\Users\\Rani\\Desktop\\AI Pycharm Project\\labelled data\\data\\Train\\' val_dir = 'C:\\Users\\Rani\\Desktop\\AI Pycharm Project\\labelled data\\data\\Validation\\' test_dir = 'C:\\Users\\Rani\\Desktop\\AI Pycharm Project\\labelled data\\data\\Test\\' train_datagen = ImageDataGenerator(horizontal_flip=True, zoom_range=0.1, preprocessing_function=preprocess_input) validation_datagen = ImageDataGenerator( preprocessing_function=preprocess_input) test_datagen = ImageDataGenerator(preprocessing_function=preprocess_input) # Change the batchsize according to your system RAM train_batchsize = 8 val_batchsize = 8 train_generator = train_datagen.flow_from_directory( train_dir, target_size=(img_shape[0], img_shape[1]), batch_size=train_batchsize,
noise = np.random.normal(0, deviation, img.shape) img += noise np.clip(img, 0., 255.) return img # Press the green button in the gutter to run the script. if __name__ == '__main__': train_photos = np.array(load_files(train_data_path)) sample = GaussianNoise(20, dtype=tf.float64) # Image transformer datagen = ImageDataGenerator( shear_range=0.2, zoom_range=[0.75, 1], rotation_range=5, horizontal_flip=True, dtype='uint8', preprocessing_function=lambda x: random_hue(x, seed=9, max_delta=0.05)) # datagen = ImageDataGenerator( # shear_range=0.0, # zoom_range=0.0, # rotation_range=0, # horizontal_flip=False, # dtype='uint8' # ) #train_photos_lab = np.array([cv2.cvtColor(image, cv2.COLOR_RGB2Lab) for image in train_photos]) # del train_photos # test_photos_color = np.array(load_files(test_data_path))
from PIL import Image import os, glob, numpy as np from keras_preprocessing.image import ImageDataGenerator, load_img import matplotlib.pyplot as plt img_dir = 'C:/cpi_image_test2' categories = ['BW_image', 'no_BW_image'] np_classes = len(categories) from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img data_aug_gen = ImageDataGenerator(rescale=1. / 255, rotation_range=0, width_shift_range=0.1, height_shift_range=0.1, shear_range=0.5, zoom_range=[0.8, 2.0], horizontal_flip=True, vertical_flip=False, fill_mode='nearest') img_dir = 'C:/cpi_image_test2' img_dir_detail = img_dir + "/" + "BW_image" + "/" files = glob.glob(img_dir_detail + '*.png') save_to_dir = 'C:/cpi_image_test2/BW_image' ## DATA Argumentation for i, f in enumerate(files): png_name = ''.join(f.split()).split('\\')[1][:-4] save_to_dir1 = save_to_dir + '/' + png_name if not os.path.exists(save_to_dir1):
target_size = (160, 270) img = image.load_img(imagePath) plt.imshow(img) img = image.load_img(imagePath, target_size=target_size, interpolation="lanczos") plt.imshow(img) train_datagen = ImageDataGenerator( rescale = 1./255, # zoom_range=0.2, # rotation_range=40, # horizontal_flip=True, # width_shift_range=0.2, # height_shift_range=0.2, # shear_range=0.2, fill_mode='nearest', # featurewise_center=False, # set input mean to 0 over the dataset # samplewise_center=False, # set each sample mean to 0 # featurewise_std_normalization=False, # divide inputs by std of the dataset # samplewise_std_normalization=False, # divide each input by its std # zca_whitening=False, # apply ZCA whitening # vertical_flip=False ) validation_datagen = ImageDataGenerator( rescale = 1./255, ) train_generator = train_datagen.flow_from_directory( training_path,
class TimeSeriesGenerator(Sequence): def __init__(self, zip_file: zipfile.ZipFile, batch_size: int, frames: list, target_classes: list, target_classes_rules: dict, img_height, img_width, aug=None, series_len=1, series_interval=1): self.zip_file = zip_file self.aug = aug self.class_num = len(target_classes) self.is_softmax_activation = self.class_num > 1 self.batch_size = batch_size self.series_len = series_len self.img_width = img_width self.img_height = img_height self._class_mapping = self._get_class_mapping(target_classes, target_classes_rules) self._samples = self._get_samples(frames, series_len, series_interval) self._image_processor = ImageDataGenerator(**(aug or {})) def _get_samples(self, frames, series_len, series_interval): samples = [] # parse frame names pattern = r'(?P<video_name>video.+)_frame_(?P<frame>\d+)' labelled_frames = (re.match(pattern, f) for f in frames) labelled_frames = [{ 'video_name': m.group('video_name'), 'frame': int(m.group('frame')), 'name': m.string } for m in labelled_frames] # read video fps info from auxilary json file video_fps = self.zip_file.read('video_fps.json').decode('utf-8') video_fps = json.loads(video_fps) all_frames = set(f for f in self.zip_file.namelist() if f.startswith('images/')) all_masks = set(f for f in self.zip_file.namelist() if f.startswith('segments/')) # create samples from labelled frames for frame in labelled_frames: series_step = int(video_fps[frame['video_name']] * series_interval) series_end = frame['frame'] series_start = max(series_end - series_step * (series_len - 1), 0) frames_idx = [ *range(series_start, series_end, series_step), series_end ] if len(frames_idx) == series_len: series = [ '{}_frame_{}'.format(frame['video_name'], idx) for idx in frames_idx ] # make sure all images and masks exist before process assert all('images/{}.jpg'.format(f) in all_frames for f in series),\ 'images sequence not found: video {video_name}, frame {frame}'.format(**frame) assert 'segments/{}.png'.format(series[-1]) in all_masks,\ 'segments not found: video {video_name}, frame {frame}'.format(**frame) samples.append(series) return samples def _get_class_mapping(self, target_classes, target_classes_rules): mapping = {} #read labels labels = self.zip_file.read('labels.txt').decode('utf-8').split('\r\n') labels = { int(l.split(':')[0]): l.split(':')[1].lstrip(' ') for l in labels } for target_idx, target_class in enumerate(target_classes): if target_class in target_classes_rules: for rule_list_item in target_classes_rules[target_class]: label_idx = next((idx for idx, label in labels.items() if label == rule_list_item), None) if label_idx is not None: mapping[label_idx] = target_idx else: raise Exception( "Can't find mapping target class '{}' with rule '{}' in labels: '{}'" .format(target_class, rule_list_item, dict(labels))) else: # skip exception on background class if target_idx == 0 and labels[0] == 'background': continue raise Exception( "Can't find mapping rule for the class '{}' with rules '{}' and labels: '{}'" .format(target_class, target_classes_rules, dict(labels))) for i in range(self.class_num): if i not in mapping.values(): # minus in key mean that it is skipped, but could be used as background # extra -1 is used for the i==0 - there are no -0 with type int mapping[-i - 1] = i return mapping def _unpack_to_classes_with_mapping(self, mask): new_y = np.zeros(mask.shape[:2] + (self.class_num, ), dtype=mask.dtype) filled_mask = np.zeros(mask.shape[:2], dtype=np.bool_) items_to_map = sorted(self._class_mapping.items(), key=lambda x: x[0], reverse=True) for source_idx, target_idx in items_to_map: # filling class 0 with all not filled pixels when it has softmax activation if self.is_softmax_activation and target_idx == 0: new_y[:, :, target_idx][~filled_mask] = 1 continue # updates only pixes with 0 values - it will allow to combine many masks into 1 without overwritten pixels update_mask = (new_y[:, :, target_idx] == 0) & (mask == source_idx) # disable pixel filling when it already filled by previous classes if self.is_softmax_activation: update_mask[update_mask & filled_mask] = False filled_mask = filled_mask | update_mask new_y[:, :, target_idx][update_mask] = 1 return new_y def __len__(self): return int(np.ceil(len(self._samples) / self.batch_size)) def __getitem__(self, idx): batch_start = idx * self.batch_size batch_end = min(batch_start + self.batch_size, len(self._samples)) x_batch = np.zeros((batch_end - batch_start, self.series_len, self.img_height, self.img_width, 3), dtype=np.float32) y_batch = np.zeros((batch_end - batch_start, self.img_height, self.img_width, self.class_num), dtype=np.uint8) for batch_idx, sample_idx in enumerate(range(batch_start, batch_end)): # apply same tranformations to all frames in a sample transform_params = self._image_processor.get_random_transform( (self.img_height, self.img_width)) for series_idx, frame_name in enumerate(self._samples[sample_idx]): # load image img_byte_string = self.zip_file.read( 'images/{}.jpg'.format(frame_name)) img = np.frombuffer(img_byte_string, dtype=np.uint8) img = cv2.imdecode(img, cv2.IMREAD_COLOR) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # resize to output size img = cv2.resize(img, (self.img_width, self.img_height), interpolation=cv2.INTER_LINEAR) # apply augmentation img = self._image_processor.apply_transform( img, transform_params) x_batch[batch_idx, series_idx, :, :, :] = img # load mask mask_byte_string = self.zip_file.read('segments/{}.png'.format( self._samples[sample_idx][-1])) mask = np.frombuffer(mask_byte_string, dtype=np.uint8) mask = cv2.imdecode(mask, cv2.IMREAD_GRAYSCALE) # resize to output size mask = cv2.resize(mask, (self.img_width, self.img_height), interpolation=cv2.INTER_NEAREST) # transform graysacale mask to class_num channel mask mask = self._unpack_to_classes_with_mapping(mask) # disable some transformations for mask and apply augmentation transform_params['channel_shift_intensity'] = None transform_params['brightness'] = None mask = self._image_processor.apply_transform( mask, transform_params) y_batch[batch_idx, :, :, :] = mask return x_batch, y_batch
train_labels = pd.read_csv(os.path.join(WORK_DIR, "train.csv")) train_labels.label = train_labels.label.astype('str') Y = train_labels[['label']] n = len(train_labels) skf = StratifiedKFold(n_splits=5) valid_accuracy = [] valid_loss = [] fold_var = 1 train_idg = ImageDataGenerator( preprocessing_function=None, rotation_range=45, zoom_range=0.2, horizontal_flip=True, vertical_flip=True, fill_mode='nearest', shear_range=0.1, height_shift_range=0.1, width_shift_range=0.1) validation_idg = ImageDataGenerator(validation_split=0.2) for train_index, val_index in skf.split(np.zeros(n), Y): training_data = train_labels.iloc[train_index] validation_data = train_labels.iloc[val_index] train_generator = train_idg.flow_from_dataframe(training_data, directory=os.path.join(WORK_DIR, "train_images"), subset="training", x_col="image_id",
# print(img_path) img = mpimg.imread(img_path) plt.imshow(img) plt.axis('Off') plt.show() import tensorflow as tf from keras_preprocessing import image from keras_preprocessing.image import ImageDataGenerator TRAINING_DIR = r'C:\Users\kirin\tmp\rps' training_datagen = ImageDataGenerator( rescale = 1./255, rotation_range = 40, width_shift_range = 0.2, height_shift_range = 0.2, shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode='nearest') VALIDATION_DIR = r'C:\Users\kirin\tmp\rps-test-set' validation_datagen = ImageDataGenerator(rescale=1./255) train_generator = training_datagen.flow_from_directory( TRAINING_DIR, target_size=(150,150), class_mode='categorical' ) validation_generator = validation_datagen.flow_from_directory(
plt.show() plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train', 'test'], loc='upper left') plt.show() if __name__ == '__main__': x_train, y_train, x_test, y_test = load_and_preprocess_data() model = construct_model() train_datagen = ImageDataGenerator(rotation_range=15, width_shift_range=0.1, height_shift_range=0.1, horizontal_flip=True) batch_size = 64 train_generator = train_datagen.flow(x=x_train, y=y_train, batch_size=batch_size, shuffle=True) checkpointer = ModelCheckpoint( filepath="models/{epoch:02d}-{val_acc:.4f}-{val_loss:.4f}.hd5", save_weights_only=False, verbose=1, save_best_only=False) reduce_lr = ReduceLROnPlateau(monitor='val_acc',