def train_model(dataset_dir: str, anno_path: str, model: modellib.MaskRCNN,
training_set: List[str], validation_set: List[str]) -> None:
"""Train Mask-RCNN model
Args:
dataset_dir: data set directory
anno_path: path of annotation file
model: Mask RCNN model to train
training_set: image file names in training set
validation_set: image file names in validation set
"""
# Training dataset.
dataset_train = CarDamageDataset()
dataset_train.load_car_damage(dataset_dir, anno_path, fnames=training_set)
dataset_train.prepare()
# Validation dataset
dataset_val = CarDamageDataset()
dataset_val.load_car_damage(dataset_dir, anno_path, fnames=validation_set)
dataset_val.prepare()
# Since we're using a very small dataset, and starting from
# COCO trained weights, we don't need to train too long. Also,
# no need to train all layers, just the heads should do it.
print("Training network heads")
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=10,
layers='heads')
return None
def train(config=SeptinConfig()):
"""Train the model."""
# Training dataset.
dataset_train = SeptinDataset()
dataset_train.load_Septin("train")
dataset_train.prepare()
print('Train: %d' % len(dataset_train.image_ids))
# Validation dataset
dataset_val = SeptinDataset()
dataset_val.load_Septin("test")
dataset_val.prepare()
print('Test: %d' % len(dataset_val.image_ids))
config = SeptinConfig()
config.display()
# define the model
model = MaskRCNN(mode='training', model_dir='./', config=config)
# load weights (mscoco) and exclude the output layers
model.load_weights('mask_rcnn_coco.h5',
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox",
"mrcnn_mask"
])
# train weights (output layers or 'heads')
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=8,
layers='heads')
def main():
# load training set (75/15/15 split between train/test/validation)
train_set = prep_dataset(os.path.join(DATA_PATH, 'train'))
test_set = prep_dataset(os.path.join(DATA_PATH, 'test'))
# generate model
config = LicensePlateConfig()
model = MaskRCNN(mode='training',
model_dir=os.path.join(WEIGHT_PATH, 'log/'),
config=config)
# load pre-trained MS COCO weights
model.load_weights(os.path.join(WEIGHT_PATH, 'mask_rcnn_coco.h5'),
by_name=True,
exclude=[
'mrcnn_class_logits', 'mrcnn_bbox_fc', 'mrcnn_bbox',
'mrcnn_mask'
])
# train top layer
model.train(train_set,
test_set,
learning_rate=config.LEARNING_RATE,
epochs=10,
layers='heads')
# adjust learning rate for finetuning to avoid overfitting
config.LEARNING_RATE = 1e-5
# finetune all layers
model.train(train_set,
test_set,
learning_rate=config.LEARNING_RATE,
epochs=5,
layers='all')
def train(model: MaskRCNN,
learning_rate=config.LEARNING_RATE,
epochs=1,
layers='all'):
logging.warning(f"Start {layers} training...")
with tf.device("/device:GPU:0"):
model.train(dataset_train,
dataset_val,
learning_rate=learning_rate,
epochs=epochs,
layers=layers)
def train():
df = pd.read_csv(config.train_path)
df = df.sample(frac=1).reset_index(drop=True)
x_train = df['img_path'].values.tolist()
y_train = df['box'].values.tolist()
dev_sample_index = -1 * int(0.1 * float(len(y_train)))
x_train, x_val = x_train[:dev_sample_index], x_train[dev_sample_index:]
y_train, y_val = y_train[:dev_sample_index], y_train[dev_sample_index:]
print('train:{}, val:{}, all:{}'.format(len(y_train), len(y_val),
df.shape[0]))
# load the train dataset
train_set = MyDataset()
train_set.load_dataset(x_train, y_train, mode='train')
train_set.prepare()
# load the val dataset
val_set = MyDataset()
val_set.load_dataset(x_val, y_val, mode='val')
val_set.prepare()
model_config = config.TrainConfig()
# define the model
model = MaskRCNN(mode='training', model_dir='./', config=model_config)
model.keras_model.metrics_tensors = []
# load weights (mscoco) and exclude the output layers
model.load_weights(config.mrcnn_model_path,
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox",
"mrcnn_mask"
])
# save checkpoint
ModelCheckpoint = keras.callbacks.ModelCheckpoint(config.keras_model_dir,
verbose=0,
save_best_only=True,
save_weights_only=True)
callbacks = [ModelCheckpoint]
model.train(train_set,
val_set,
learning_rate=model_config.LEARNING_RATE,
epochs=config.epochs_num,
layers='heads',
custom_callbacks=callbacks)
def main(ann_file_path, images_path, learning_rate, epochs, val_percentage):
# train set
train_set = OurDataset()
train_set.load_dataset(images_path,
ann_file_path,
is_train=True,
val_percentage=val_percentage)
train_set.prepare()
print('Train images: %d' % len(train_set.image_ids))
# val set
val_set = OurDataset()
val_set.load_dataset(images_path,
ann_file_path,
is_train=False,
val_percentage=val_percentage)
val_set.prepare()
print('Validation images: %d' % len(val_set.image_ids))
# prepare config
config = TrainConfig()
# define the model
model = MaskRCNN(mode='training',
model_dir='/home/test/data/trained_models/',
config=config)
# load weights (mscoco)
model.load_weights('/home/test/data/mask_rcnn_coco.h5',
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox",
"mrcnn_mask"
])
print('START TRAINING')
# train weights (output layers or 'heads')
model.train(train_set,
val_set,
learning_rate=config.LEARNING_RATE,
epochs=epochs,
layers='all')
print('Training DONE')
def train(model: MaskRCNN, path_to_dataset: str = paths.IMAGES_PATH) -> None:
# Training dataset
dataset_train = PlateDataset()
dataset_train.load_plates(path_to_dataset, "all_pics_aug/",
path_to_dataset + "all_pics_aug/ann.json")
dataset_train.prepare()
# Validation dataset
dataset_val = PlateDataset()
dataset_val.load_plates(path_to_dataset, "all_pics_aug/",
path_to_dataset + "all_pics_aug/hundred.json")
dataset_val.prepare()
print("Training network heads")
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=EPOCHS_NUMBER,
layers='heads')
def createModel(layer):
# prepare config
config = HumanConfig()
config.display()
# define the model
model = MaskRCNN(mode='training', model_dir='./model', config=config)
# load weights (mscoco) and exclude the output layers
model.load_weights('./mask_rcnn_coco.h5',
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox",
"mrcnn_mask", "conv1"
])
for lay in layer:
# train weights (output layers or 'heads')
model.train(train_set,
test_set,
learning_rate=config.LEARNING_RATE,
epochs=35,
layers=lay)
def main():
config = ObjectConfig()
model = MaskRCNN(mode='training', model_dir='./', config=config)
model.load_weights('../mrcnn/mask_rcnn_coco.h5',
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox",
"mrcnn_mask"
])
train_set = ObjectDataset()
train_set.load_dataset('train')
train_set.prepare()
print('Train: %d' % len(train_set.image_ids))
model.train(train_set,
train_set,
learning_rate=config.LEARNING_RATE,
epochs=1,
layers='heads')
def fit(self, train_dataset: DigitDataset, val_dataset: DigitDataset,
epochs: int = 20, layers: str = 'heads', logs_path: str = paths.WEIGHT_LOGS_PATH,
weights_path: str = paths.WEIGHTS_PATH + 'pretrained/mask_rcnn_coco.h5') -> None:
train_dataset.load()
train_dataset.prepare()
val_dataset.load()
val_dataset.prepare()
self.config.EPOCHS = epochs
self.config.STEPS_PER_EPOCH = train_dataset.set_size
model = MaskRCNN(mode='training', config=self.config, model_dir=logs_path)
model.load_weights(weights_path, by_name=True, exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc",
"mrcnn_bbox", "mrcnn_mask"])
print("Training network")
model.train(train_dataset, val_dataset,
learning_rate=self.config.LEARNING_RATE,
epochs=self.config.EPOCHS,
layers=layers)
def run(path_to_csv="train.csv"):
wandb.init()
data = utils.load(path_to_csv)
classes = utils.determine_classes(data)
train, test = train_test_split(data, test_size=0.2)
train_set = prepare_dataset(train, "./train/", classes)
valid_set = prepare_dataset(test, "./train/", classes)
print('Train: %d' % len(train_set.image_ids))
print('Test: %d' % len(valid_set.image_ids))
config = TrainingConfig()
callbacks = []
if wandb_found:
callbacks.append(WandbCallback())
config.STEPS_PER_EPOCH = wandb.config.STEPS_PER_EPOCH
config.LEARNING_RATE = wandb.config.LEARNING_RATE
config.LEARNING_MOMENTUM = wandb.config.LEARNING_MOMENTUM
config.WEIGHT_DECAY = wandb.config.WEIGHT_DECAY
else:
# configure params through directly editing the TrainingConfig class
pass
model = MaskRCNN(mode="training", model_dir="train", config=config)
model.load_weights("mask_rcnn_coco.h5",
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox",
"mrcnn_mask"
])
# tb = keras.callbacks.TensorBoard(log_dir="./logs")
model.train(train_set,
valid_set,
learning_rate=config.LEARNING_RATE,
epochs=wandb.config.EPOCHS,
layers="heads",
custom_callbacks=callbacks)
class MaskR:
def __init__(self, model_dir, init_with='coco'):
self.model_dir = model_dir
self.init_with = init_with
self.test_model = None
def train(self, dataset_train, dataset_val, epochs):
'''
'''
t0 = time.time()
print ('GPU available:', tf.test.is_gpu_available())
self.mode = 'training'
self.config = C.TrainingConfig()
if not os.path.exists(self.model_dir):
os.mkdir(self.model_dir)
self.model = MaskRCNN(self.mode, self.config, self.model_dir)
# Which weights to start with?
# imagenet, coco, or last
# Local path to trained weights file
COCO_MODEL_PATH = os.path.join(self.model_dir, "mask_rcnn_coco.h5")
# Download COCO trained weights from Releases if needed
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
if self.init_with == "imagenet":
self.model.load_weights(self.model.get_imagenet_weights(), by_name=True)
elif self.init_with == "coco":
# Load weights trained on MS COCO, but skip layers that
# are different due to the different number of classes
# See README for instructions to download the COCO weights
self.model.load_weights(COCO_MODEL_PATH, by_name=True,
exclude=["mrcnn_class_logits", "mrcnn_bbox_fc",
"mrcnn_bbox", "mrcnn_mask"])
elif self.init_with == "last":
# Load the last model you trained and continue training
self.model.load_weights(model.find_last(), by_name=True)
print ('MaskRCNN Setup complete after', time.time()-t0, 'seconds')
t0 = time.time()
history = History()
self.model.train(dataset_train, dataset_val, custom_callbacks=[history],
learning_rate=self.config.LEARNING_RATE,
epochs=epochs,
layers='heads')
p.dump(history.history, open(os.path.join(self.model_dir, "history.p"), "wb"))
print ('MaskRCNN Training complete after', time.time()-t0, 'seconds')
return history
def predict(self, images, verbose=False):
'''
'''
if not self.test_model:
model = MaskRCNN(mode="inference",
config=C.TestingConfig(),
model_dir=self.model_dir)
weights = model.find_last()
model.load_weights(weights, by_name=True)
self.test_model = model
results = []
for image in images:
results.append(self.test_model.detect([image])[0])
if verbose:
r = results[0]
visualize.display_instances(images[0], r['rois'], r['masks'], r['class_ids'],
["",""], r['scores'],figsize=(10,10))
return results
# define the model, load weights and run training
model = MaskRCNN(mode='training', model_dir='./', config=config)
try:
weights, old_epochs = find_last(model)
except FileNotFoundError:
pr('Using initial weights from', C.initial_weights)
if os.path.isfile('train.log'):
pr('Backing up training log')
os.rename('train.log', 'train.log.old')
model.load_weights(C.initial_weights,
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox",
"mrcnn_mask"
])
eps = C.epochs
pr('Training', eps, 'epochs.')
else:
pr('Using weights from: ', weights)
model.load_weights(weights, by_name=True)
eps = int(old_epochs) + C.epochs
pr('Training from epoch', old_epochs, 'to epoch', eps)
model.train(train_set,
test_set,
custom_callbacks=[logger],
learning_rate=config.LEARNING_RATE,
epochs=eps,
layers=C.train_layers)
inf=self.image_info[image_id]
path=inf["path"]
return path
tk="/content/drive/My Drive/My_dataset/pictures_1.json"
ih="/content/drive/My Drive/My_dataset/"
train_set = HandwrittingDataset(tk)
train_set.load_dataset(ih, Train=True)
train_set.prepare()
print('Train: %d' % len(train_set.image_ids))
test_set = HandwrittingDataset(tk)
test_set.load_dataset(ih, Train=False)
test_set.prepare()
print('Test: %d' % len(test_set.image_ids))
class HandwrittingConfig(Config):
NAME="HandwrittingConfig"
NUM_CLASSES=1+1
STEPS_PER_EPOCH=274
IMAGE_PER_GPU=2
#weights directory in google drive
w="/content/drive/My Drive/mask_rcnn_coco.h5"
config=HandwrittingConfig()
#config.display()
model=MaskRCNN(mode="training",model_dir="/content/drive/My Drive/handwritting_models/",config=config)
#load pretrained weights
model.load_weights(w,by_name=True,exclude=["mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox", "mrcnn_mask"])
#define augumentation techniques
augumentation=iaa.Sequential([iaa.Sometimes(0.6,iaa.GaussianBlur(sigma=(0,0.4))),iaa.Flipud(0.2)),iaa.Fliplr(0.5)],random_order=True)
#train model
model.train(train_set, test_set, learning_rate=config.LEARNING_RATE, epochs=20,layers="heads",augmentation=augumentation)
# initialize the image augmentation process
aug = iaa.SomeOf(
(0, 2), [iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Affine(rotate=(-10, 10))])
# define the model
model = MaskRCNN(mode='training', model_dir='./', config=config)
# load weights (mscoco) and exclude the output layers
model.load_weights('mask_rcnn_coco.h5',
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox",
"mrcnn_mask"
])
# train weights (output layers or 'heads')
# train *just* the layer heads
model.train(train_set,
test_set,
learning_rate=config.LEARNING_RATE,
epochs=20,
layers='heads',
augmentation=aug)
# unfreeze the body of the network and train *all* layers
model.train(train_set,
test_set,
learning_rate=config.LEARNING_RATE / 10,
epochs=20,
layers='all',
augmentation=aug)
train_set.prepare()
print('Train: %d' % len(train_set.image_ids))
# prepare test/val set
test_set = ObjectDataset()
test_set.load_dataset('/home/student/charcoal_hearth_hill', is_train=False)
test_set.prepare()
print('Test: %d' % len(test_set.image_ids))
# prepare config
config = ObjectConfig()
config.display()
# define the model
model = MaskRCNN(mode='training', model_dir='/storage/model/', config=config)
# load weights (mscoco) and exclude the output layers
model.load_weights('/home/student/data_5000_project/programs/R-CNN/Mask_RCNN/mask_rcnn_coco.h5', by_name=True, exclude=["mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox", "mrcnn_mask"])
# train weights (output layers or 'heads')
model.train(train_set, test_set, learning_rate=config.LEARNING_RATE, epochs=12, layers='heads')
history1 = model.keras_model.history.history
#https://github.com/crowdAI/crowdai-mapping-challenge-mask-rcnn/blob/master/Training.ipynb
#Sharada Mohanty [email protected]
#print("Fine tune Resnet stage 4 and up")
model.train(train_set, test_set, learning_rate=config.LEARNING_RATE, epochs=24, layers='4+')
history2 = model.keras_model.history.history
#Rosebrock, Adrian. Deep Learning for Computer Vision with Python Vol. 3, Vol. 3. 2019. p360
#epochs must be epochs+n below
model.train(train_set, test_set, learning_rate=config.LEARNING_RATE /10, epochs=36, layers="all")
#Thanks to Renu Khandelwal https://towardsdatascience.com/object-detection-using-mask-r-cnn-on-a-custom-dataset-4f79ab692f6d
history3 = model.keras_model.history.history
dataset_train.prepare()
# Validation dataset
dataset_val = CloudsDataset()
dataset_val.load_batch(validation_images)
dataset_val.prepare()
#Prepare configuration
config = CloudsConfig()
#Create model in training model
model = MaskRCNN(mode='training', model_dir='./', config=config)
#Load pre-trained weights (MSCOCO) and exclude the output layers
model.load_weights('mask_rcnn_coco.h5', by_name=True, exclude=["mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox", "mrcnn_mask"])
#Train weights (output layers or 'heads')
model.train(dataset_train, dataset_val, learning_rate=config.LEARNING_RATE, epochs=10, layers='heads', augmentation=image_augmentation)
#Create instance of inference configuration class
inference_config = InferenceConfig()
#Recreate the model in inference mode
model = MaskRCNN(mode='inference', config=inference_config, model_dir='./')
#Get path to saved weights
model_path = 'mask_rcnn_clouds_config_0001.h5'
#Load trained weights
print("Loading weights from ", model_path)
model.load_weights(model_path, by_name=True)
#Test on random validation image
class RCNNDetector(IObjectDetection):
def __init__(self, dataset_path, dataset_name):
super(RCNNDetector, self).__init__(dataset_path, dataset_name)
self.train_set = ClassDataset()
self.test_set = ClassDataset()
# self.train_set = KangarooDataset()
# self.test_set = KangarooDataset()
self.model = "rcnn"
self.modelWeights = None
self.config = Config()
def transform(self):
# fn.organizeDataset(self.DATASET_NAME, self.OUTPUT_PATH, self.DATASET)
self.train_set.load_dataset(
os.path.join(self.OUTPUT_PATH, self.DATASET_NAME), True)
# self.train_set.load_dataset(dataset_path, True)
self.train_set.prepare()
#self.test_set.load_dataset(os.path.join(self.OUTPUT_PATH,self.DATASET_NAME), False)
# self.test_set.load_dataset(dataset_path, False)
#self.test_set.prepare()
# def organize(self, train_percentage):
# super(RCNNDetector, self).organize( train_percentage)
def createModel(self):
# En este caso tambien debe ser output por que ya se ha hecho la division y se ha guardado
classes_file = os.path.join(self.OUTPUT_PATH, self.DATASET_NAME,
"classes.names")
file = open(os.path.join(classes_file))
classes = []
for line in file:
classes.append(line)
n_classes = fn.count_classes(classes)
n_images = len(
glob.glob(
os.path.join(self.OUTPUT_PATH, self.DATASET_NAME,
"train/JPEGImages/*.jpg")))
ClassConfig.NUM_CLASSES += n_classes
ClassConfig.NAME = self.DATASET_NAME
ClassConfig.N_IMAGES = n_images
ClassConfig.STEPS_PER_EPOCH = n_images // (ClassConfig.GPU_COUNT *
ClassConfig.IMAGES_PER_GPU)
self.config = ClassConfig()
# Por lo mismo de antes. El dataset ya esta procesado y guardado ahi. Es donde se tiene que trabajar con el en este caso
# self.modelWeights = MaskRCNN(mode='training', model_dir=os.path.join(self.OUTPUT_PATH,"model"), config=self.config)
if not os.path.exists(
os.path.join(self.OUTPUT_PATH, self.DATASET_NAME, "models")):
os.mkdir(
os.path.join(self.OUTPUT_PATH, self.DATASET_NAME, "models"))
self.modelWeights = MaskRCNN(mode='training',
model_dir=os.path.join(
self.OUTPUT_PATH, self.DATASET_NAME,
"models"),
config=self.config)
if not os.path.exists(
'objectDetectors/RCNNObjectDetector/mask_rcnn_coco.h5'):
wget.download(
"https://www.dropbox.com/s/12ou730jt730qvu/mask_rcnn_coco.h5?dl=1",
'objectDetectors/RCNNObjectDetector/mask_rcnn_coco.h5')
self.modelWeights.load_weights(
'objectDetectors/RCNNObjectDetector/mask_rcnn_coco.h5',
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox",
"mrcnn_mask"
])
def train(self, framework_path=None, n_gpus=1):
ClassConfig.GPU_COUNT = n_gpus
# self.model.train(self.TRAIN_SET, self.TEST_SET, learning_rate=self.CONFIG.LEARNING_RATE, epochs=5, layers='heads')
self.modelWeights.train(self.train_set,
self.train_set,
learning_rate=self.config.LEARNING_RATE,
epochs=5,
layers='heads')
results = []
# Path(os.path.join(self.OUTPUT_PATH, self.DATASET_NAME, "models")).rglob(".h5")
for r in glob.glob(
os.path.join(self.OUTPUT_PATH, self.DATASET_NAME, "models",
"**", "*5.h5")):
results.append(r)
# results = [p for p in os.listdir(os.path.join(self.OUTPUT_PATH, self.DATASET_NAME,"models")) if p.endswith(".h5") and "mask_rcnn_" + self.DATASET_NAME + "_0005" in p]
shutil.copy2(
results[0],
os.path.join(self.OUTPUT_PATH, self.DATASET_NAME, "models",
"mask_rcnn_" + self.DATASET_NAME + "_0005.h5"))
def evaluate(self):
rcnnPredict = RCNNPredict(
os.path.join(self.OUTPUT_PATH, self.DATASET_NAME, "models",
"mask_rcnn_" + self.DATASET_NAME.lower() +
"_0005.h5"),
os.path.join(self.OUTPUT_PATH, self.DATASET_NAME, "classes.names"))
map = Map(rcnnPredict, self.DATASET_NAME,
os.path.join(self.OUTPUT_PATH, self.DATASET_NAME),
self.model)
map.evaluate()
def main(argv):
mode = ''
weights = 'mask_rcnn_coco.h5'
image = ''
dataset = 'data/'
try:
opts, args = getopt.getopt(argv, 'hm:w:i:d:',
['mode,weights,image,dataset'])
except getopt.GetoptError:
print(
'mask_rcnn.py -m <mode=train, eval or splash> -w <weights> -i <image> -d <dataset>'
)
sys.exit()
for opt, arg in opts:
if opt == '-h':
print(
'mask_rcnn.py -m <mode=train, eval or splash> -w <weights> -i <image> -d <dataset>'
)
sys.exit()
elif opt in ('-m', '--mode'):
mode = arg
elif opt in ('-w', '--weights'):
weights = arg
elif opt in ('-i', '--image'):
image = arg
elif opt in ('-d', '--dataset'):
dataset = arg
if mode == 'train':
print('TRAINING MODE:')
print('WITH WEIGHTS: ', weights)
# prepare train set
train_set = HumanInVesselDangerDataset()
train_set.load_dataset('data/', is_train=True)
train_set.prepare()
print('Train: %d' % len(train_set.image_ids))
# prepare test set
test_set = HumanInVesselDangerDataset()
test_set.load_dataset('data/', is_train=False)
test_set.prepare()
print('Test: %d' % len(test_set.image_ids))
# prepare config
config = VesselConfig()
config.display()
# # define the model
model = MaskRCNN(mode='training', model_dir='./models/', config=config)
# load weights (mscoco) and exclude the output layers
model.load_weights(weights,
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc",
"mrcnn_bbox", "mrcnn_mask"
])
# train weights (output layers or 'heads')
model.train(train_set,
test_set,
learning_rate=config.LEARNING_RATE,
epochs=10,
layers='heads')
elif mode == 'eval':
print('EVALUATION MODE:')
print('WITH WEIGHTS: ', weights)
# prepare validation set
validation_set = HumanInVesselDangerDataset()
validation_set.load_dataset('validation/', is_validation=True)
validation_set.prepare()
print('Validation: %d' % len(validation_set.image_ids))
# prepare config
config = VesselEvalConfig()
config.display()
# define the model
model = MaskRCNN(mode='inference', model_dir='./', config=config)
# load model weights
model.load_weights(weights, by_name=True)
# evaluate model on validation dataset
val_mAP = evaluate_model(validation_set, model, config)
print("Validation mAP: %.3f" % val_mAP)
elif mode == 'splash':
print("SPLASH MODE: ")
if image == '':
print('use `-i <loc/of/img>` to splash an image')
sys.exit()
print('WITH WEIGHTS: ', weights)
print('USING DATASET: ', dataset)
print('SPLASHING IMAGE: ', image)
# prepare validation set
validation_set = HumanInVesselDangerDataset()
validation_set.load_dataset(dataset, is_validation=True)
validation_set.prepare()
print('Validation: %d' % len(validation_set.image_ids))
# prepare config
config = VesselEvalConfig()
config.display()
# define the model
model = MaskRCNN(mode='inference', model_dir='./', config=config)
# load model weights
model.load_weights(weights, by_name=True)
detect_and_color_splash(model, image)
router_train = DatasetXML()
router_train.load_dataset(dataset_dir, label, train_imgs)
router_train.prepare()
print('Train: %d' % len(router_train.image_ids))
router_test = DatasetXML()
router_test.load_dataset(dataset_dir, label, test_imgs)
router_test.prepare()
print('Test: %d' % len(router_test.image_ids))
else: # pkl format
file_name = 'data_val2017-laptop'
pkldata = pkl.load(open(os.path.join(dataset_dir, file_name+'.pkl'), 'rb'))
# =============== train models ===============
# prepare config
config = Config()
config.NAME = label + "_cfg" # Give the configuration a recognizable name
config.STEPS_PER_EPOCH = n_steps # Number of training steps per epoch
config.NUM_CLASSES = 1 + 1 # Number of classes (background + router)
model = MaskRCNN(mode='training', model_dir=model_root_dir, config=config)
model.load_weights(model_dir, by_name=True,
exclude=["mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox", "mrcnn_mask"])
model.train(router_train, router_test, learning_rate=config.LEARNING_RATE, epochs=n_epochs, layers='heads')
# session stuff
session = tf.Session(config=config)
session.run(tf.global_variables_initializer())
session.run(tf.local_variables_initializer())
# initialiazing model
model = MaskRCNN(mode='training',
config=severstal_config,
model_dir='modeldir')
# we will retrain starting with the coco weights
model.load_weights('mask_rcnn_coco.h5',
by_name=True,
exclude=[
'mrcnn_bbox_fc', 'mrcnn_class_logits', 'mrcnn_mask',
'mrcnn_bbox'
])
### %time
# ignore UserWarnongs
import warnings
warnings.filterwarnings('ignore', category=UserWarning)
# training at last
model.train(dataset_train,
dataset_validate,
epochs=1,
layers='heads',
learning_rate=severstal_config.LEARNING_RATE)
history = model.keras_model.history.history
config=config,
model_dir=config.MODEL_DIR)
weights_path = config.COCO_WEIGHTS_PATH
# Download weights file
if not os.path.exists(weights_path):
utils.download_trained_weights(weights_path)
# don't load last layers because we are going to train it
model.load_weights(weights_path,
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox",
"mrcnn_mask"
])
dataset_train = Data()
dataset_train.load(config.DATA_DIR, "train")
dataset_train.prepare()
dataset_val = Data()
dataset_val.load(config.DATA_DIR, "val")
dataset_val.prepare()
# training just heads layer is enough
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=30,
layers='heads')
def train(args):
from mrcnn.model import MaskRCNN
# Retrieve arguments
output = args.output
samples_number = args.dataset_keep
preview_only = args.preview_only
dataset_config_path = args.dataset_config_file
epochs = args.epochs
steps_per_epoch = args.steps_per_epoch
layers = args.layers
pretrain = args.pretrain
# Create config class
train_config = LeafSegmentorConfig()
# Create model
if steps_per_epoch > 0:
train_config.STEPS_PER_EPOCH = steps_per_epoch
if not os.path.exists(output):
os.makedirs(output, exist_ok=True)
model = MaskRCNN(mode="training", config=train_config, model_dir=output)
# Assemble output directories
samples_output_dir = os.path.join(model.log_dir, "samples")
# Create dataset
with open(dataset_config_path) as dataset_config_file:
dataset_config = json.load(dataset_config_file)
dataset_class = dataset_config["dataset_module"] + "." + dataset_config[
"dataset_class"]
dataset_class = locate(dataset_class)
dataset_config = dataset_config["config"]
dataset_train = dataset_class.from_config(dataset_config["train"],
train_config.IMAGE_SHAPE[0],
train_config.IMAGE_SHAPE[1])
dataset_valid = dataset_class.from_config(dataset_config["valid"],
train_config.IMAGE_SHAPE[0],
train_config.IMAGE_SHAPE[1])
# Save train samples
if samples_number != 0:
save_samples(dataset_train, samples_number, path=samples_output_dir)
if preview_only:
return # finish here
# Start training from COCO or from previously trained model
if pretrain == "COCO":
load_coco_weights(model)
else:
model.load_weights(pretrain, by_name=True)
# Start train
model.train(dataset_train,
dataset_valid,
learning_rate=train_config.LEARNING_RATE,
epochs=epochs,
layers=layers)
# Add metadata to model files (.h5)
add_config_to_model(model.log_dir)
translate_percent={
"x": (-0.1, 0.1),
"y": (-0.1, 0.1)
},
rotate=(-30, 30))),
iaa.Grayscale(alpha=(0.0, 0.7))
],
random_order=True)
LRScheduler = LearningRateScheduler(lrSchedule)
callbacks_list = [LRScheduler]
model.train(dataset_train,
dataset_validate,
epochs=epoch_size,
layers='heads',
augmentation=imgaug_set,
custom_callbacks=callbacks_list,
learning_rate=steel_defect_config.LEARNING_RATE,
optimizer='Adam')
train_hist = model.keras_model.history
print("Training is completed ............")
# Save loss to csv file
hist_df = pd.DataFrame(train_hist.history)
with open('history.csv', mode='w') as f:
hist_df.to_csv(f)
# plot the training loss and accuracy
plt.style.use("ggplot")
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-t', action='store_true', help="train the model")
parser.add_argument('-v', action='store_true', help="evaluate the model")
parser.add_argument('-d',
action='store_true',
help="debug functions of the model")
args = parser.parse_args()
if args.t or args.v or args.d:
# train set
train_set = PhilipsDataset()
train_set.load_dataset('shaver', is_train=True)
train_set.load_dataset('smart-baby-bottle', is_train=True)
train_set.load_dataset('toothbrush', is_train=True)
train_set.load_dataset('wake-up-light', is_train=True)
train_set.prepare()
print('Train: %d' % len(train_set.image_ids))
# test/val set
test_set = PhilipsDataset()
test_set.load_dataset('shaver', is_train=False)
test_set.load_dataset('smart-baby-bottle', is_train=False)
test_set.load_dataset('toothbrush', is_train=False)
test_set.load_dataset('wake-up-light', is_train=False)
test_set.prepare()
print('Test: %d' % len(test_set.image_ids))
if args.v:
# create config
cfg = PredictionConfig()
# define the model
model = MaskRCNN(mode='inference', model_dir='./', config=cfg)
# load model weights
model.load_weights('mask_rcnn_philips_cfg_0004.h5', by_name=True)
predict(test_set, model, cfg)
elif args.d:
train_set.extract_boxes("philips_data/shaver/annots/image4.xml")
elif args.t:
#train
#prepare config
config = PhilipsConfig()
config.display()
# define the model
model = MaskRCNN(mode='training', model_dir='./', config=config)
# load weights (mscoco) and exclude the output layers
model.load_weights('mask_rcnn_philips_cfg_0004.h5',
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc",
"mrcnn_bbox", "mrcnn_mask"
])
# train weights (output layers or 'heads')
model.train(train_set,
test_set,
learning_rate=config.LEARNING_RATE,
epochs=5,
layers='heads')
else:
# create config
cfg = PredictionConfig()
# define the model
model = MaskRCNN(mode='inference', model_dir='./', config=cfg)
# load model weights
model.load_weights('mask_rcnn_philips_cfg_0004.h5', by_name=True)
predict_validation(model, cfg)
def main():
# train set
train_set = AnimalDataset()
train_set.load_dataset('kangaroo', is_train=True)
train_set.prepare()
print('Train: %d' % len(train_set.image_ids))
# test/val set
test_set = AnimalDataset()
test_set.load_dataset('kangaroo', is_train=False)
test_set.prepare()
print('Test: %d' % len(test_set.image_ids))
# load an image
image_id = 0
image = train_set.load_image(image_id)
print(image.shape)
# load image mask
mask, class_ids = train_set.load_mask(image_id)
print(mask.shape)
# plot image
pyplot.imshow(image)
# plot mask
pyplot.imshow(mask[:, :, 0], cmap='gray', alpha=0.5)
pyplot.show()
# define image id
image_id = 1
# load the image
image = train_set.load_image(image_id)
# load the masks and the class ids
mask, class_ids = train_set.load_mask(image_id)
# extract bounding boxes from the masks
bbox = extract_bboxes(mask)
# display image with masks and bounding boxes
display_instances(image, bbox, mask, class_ids, train_set.class_names)
# prepare config
config = AnimalConfig()
config.display()
# define the model
model = MaskRCNN(mode='training', model_dir='./', config=config)
# load weights (mscoco) and exclude the output layers
model.load_weights('mask_rcnn_coco.h5', by_name=True, exclude=["mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox", "mrcnn_mask"])
# train weights (output layers or 'heads')
model.train(train_set, test_set, learning_rate=config.LEARNING_RATE, epochs=1, layers='heads')
# create config
cfg = AnimalConfig()
# define the model
model = MaskRCNN(mode='inference', model_dir='./', config=cfg)
# load model weights
model.load_weights('mask_rcnn_kangaroo_cfg_0002.h5', by_name=True)
# evaluate model on training dataset
train_mAP = evaluate_model(train_set, model, cfg)
print("Train mAP: %.3f" % train_mAP)
# evaluate model on test dataset
test_mAP = evaluate_model(test_set, model, cfg)
print("Test mAP: %.3f" % test_mAP)
#
## load model weights
#model_path = 'mask_rcnn_kangaroo_cfg_0005.h5'
#model.load_weights(model_path, by_name=True)
# plot predictions for train dataset
plot_actual_vs_predicted('train_actual_vs_pred.png',train_set, model, cfg)
# plot predictions for test dataset
plot_actual_vs_predicted('test_actual_vs_pred.png',test_set, model, cfg)
config = Shogo_Makishima_Config()
print("[MODEL][STATE][TRAINING]")
model = MaskRCNN(
mode="training",
model_dir="I:\GitHub\Shogo-Makishima\Datasets\Models\Shogo-Makishima\\",
config=config)
model.load_weights(
"I:\GitHub\Shogo-Makishima\Datasets\Models\\mask_rcnn_coco.h5",
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox", "mrcnn_mask"
])
model.train(train_dataset,
test_dataset,
learning_rate=config.LEARNING_RATE,
epochs=5,
layers="heads")
else:
config = Shogo_Makishima_Predictor_Config()
print("[MODEL][STATE][TEST]")
model = MaskRCNN(
mode="inference",
model_dir="I:\GitHub\Shogo-Makishima\Datasets\Models\Shogo-Makishima\\",
config=config)
model.load_weights(
"I:\GitHub\Shogo-Makishima\Datasets\Models\Shogo-Makishima\shogo_makishima_cfg20200714T1540\\mask_rcnn_shogo_makishima_cfg_0005.h5",
by_name=True)
# evaluate model on train and test dataset
# prepare train set
train_set = TableBankDataset()
# <- MODIFY -> Replace mydataset with the name of the folder containing your images and annotations
train_set.load_dataset('mydataset', is_train=True)
train_set.prepare()
print('Train: %d' % len(train_set.image_ids))
# prepare config
config = TableBankConfig()
config.display()
# define the model
model = MaskRCNN(mode='training', model_dir='./', config=config)
# load weights (mscoco) and exclude the output layers
model.load_weights('mask_rcnn_tablebank_cfg_0002.h5',
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox",
"mrcnn_mask"
])
# train weights (output layers or 'heads')
model.train(train_set,
None,
learning_rate=config.LEARNING_RATE,
epochs=2,
layers='heads')
# unfreeze the body of the network and train *all* layers
model.train(train_set,
None,
epochs=5,
layers="all",
learning_rate=config.LEARNING_RATE / 10)
return info['path']
# define a configuration for the model
class KangarooConfig(Config):
# define the name of the configuration
NAME = "kangaroo_cfg"
# number of classes (background + kangaroo)
NUM_CLASSES = 1 + 1
# number of training steps per epoch
STEPS_PER_EPOCH = 131
# prepare train set
train_set = KangarooDataset()
train_set.load_dataset('kangaroo', is_train=True)
train_set.prepare()
print('Train: %d' % len(train_set.image_ids))
# prepare test/val set
test_set = KangarooDataset()
test_set.load_dataset('kangaroo', is_train=False)
test_set.prepare()
print('Test: %d' % len(test_set.image_ids))
# prepare config
config = KangarooConfig()
config.display()
# define the model
model = MaskRCNN(mode='training', model_dir='./', config=config)
# load weights (mscoco) and exclude the output layers
model.load_weights('mask_rcnn_coco.h5', by_name=True, exclude=["mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox", "mrcnn_mask"])
# train weights (output layers or 'heads')
model.train(train_set, test_set, learning_rate=config.LEARNING_RATE, epochs=5, layers='heads')
data_val = SteelDataset(df_defects)
data_val.load_dataset(val_ids,
TRAIN_IMAGES_DIR) # val images are in the train dir
data_val.prepare()
steel_config = SteelConfig()
model = MaskRCNN(mode="training",
config=steel_config,
model_dir=str(MODEL_DIR))
if args.model.lower() == "last":
model_path = model.find_last() # Find last trained weights
elif args.model.lower() == "default":
model_path = str(COCO_MODEL_PATH)
# Exclude the last layers because they require a matching number of classes
# ^ Original comment at:
# https://github.com/matterport/Mask_RCNN/blob/master/samples/balloon/balloon.py
model.load_weights(filepath=model_path,
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc", "mrcnn_bbox",
"mrcnn_mask"
])
model.train(train_dataset=data_train,
val_dataset=data_val,
learning_rate=steel_config.LEARNING_RATE,
epochs=steel_config.NUM_EPOCHS,
layers="heads")
