def __init__(self): NUM_CLASSES = 3 + 1 input_shape = (300, 300, 3) #config_string = rospy.get_param("/traffic_light_config") #self.config = yaml.load(config_string) #self.stop_line_positions = self.config['stop_line_positions'] # get path to resources #path_to_resources = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..', '..', '..', 'tlc') # "prior boxes" in the paper #priors = pickle.load(open(os.path.join(path_to_resources, 'prior_boxes_ssd300.pkl'), 'rb')) priors = pickle.load(open('prior_boxes_ssd300.pkl', 'rb')) self.bbox_util = BBoxUtility(NUM_CLASSES, priors) # Traffic Light Classifier model and its weights self.model = SSD300(input_shape, num_classes=NUM_CLASSES) #self.model.load_weights(os.path.join(path_to_resources, self.config['classifier_weights_file']), by_name=True) #self.model.load_weights('weights.180314.hdf5', by_name=True) self.model.load_weights('checkpoints/weights.07-0.70.hdf5', by_name=True) # prevent TensorFlow's ValueError when no raised backend dummy = np.zeros((1, 300, 300, 3)) _ = self.model.predict(dummy, batch_size=1, verbose=0) # prevent TensorFlow's ValueError when no raised backend dummy = np.zeros((1, 300, 300, 3)) _ = self.model.predict(dummy, batch_size=1, verbose=0) self.is_in_progress = False self.last_result = TrafficLight.UNKNOWN
def __init__(self): self.dictindex = [] with open('./label.txt') as f: content = f.readlines() for symbol in content: symbol = symbol.replace('\n', '') split = symbol.split(' ') self.dictindex.append(split[0]) # Load model self.net = SSD300() checkpoint = torch.load('./ssdtrain0511_11.pth') checkpoint['net'] self.net.load_state_dict(checkpoint['net']) self.net.eval() self.data_encoder = DataEncoder() self.transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) ])
def predict_img(numpy_array, orig_numpy_array): # Save the original image for attachment scipy.misc.imsave('temp_cat_motion.jpg', np.uint8(orig_numpy_array)) # Number of voc_classes + 1 NUM_CLASSES = 3 input_shape=(300, 300, 3) # SSD model model = SSD300(input_shape, num_classes=NUM_CLASSES) model.load_weights('./model/weights.18-0.09.hdf5', by_name=True) bbox_util = BBoxUtility(NUM_CLASSES) # Inception v3 transfer learning model model_cnn = load_model(filepath='./model/model_v2.03-0.40.hdf5') ssd_img_size=300 img_size=299 inputs = [] images = [] images.append(orig_numpy_array) inputs.append(numpy_array.copy()) inputs = preprocess_input(np.array(inputs)) preds = model.predict(inputs, batch_size=1, verbose=0) results = bbox_util.detection_out(preds) cat_inside_image = False # If the SSD model does not find a cat, return False for i, img in enumerate(images): cat_inside_image = ssd_image(img, results, i) return cat_inside_image
def __init__(self, modelfile, shape=(300, 300, 3), num_classes=21, conf_thresh=0.6): self.input_shape = shape self.num_classes = num_classes self.conf_thresh = conf_thresh # モデル作成 model = SSD(shape, num_classes=num_classes) model.load_weights(modelfile) self.model = model # バウンディングボックス作成ユーティリティ self.bbox_util = BBoxUtility(self.num_classes)
def __init__(self): #顔検出モデルと年齢・性別検出モデルを復元 self.age_detector = load_model("transfer_Xception_29.h5") NUM_CLASSES = 2 input_shape = (300, 300, 3) priors = pickle.load(open('prior_boxes_ssd300.pkl', 'rb')) self.bbox_util = BBoxUtility(NUM_CLASSES, priors) self.face_detector = SSD300(input_shape, num_classes=NUM_CLASSES) self.face_detector.load_weights('weights.05-3.15.hdf5', by_name=True)
def __init__(self): self.node_name = "ssd_keras" rospy.init_node(self.node_name) self.class_names = [ "background", "aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor" ] self.num_classes = len(self.class_names) self.input_shape = (300, 300, 3) self.model = SSD(self.input_shape, num_classes=self.num_classes) self.model.load_weights(pkg_path + '/resources/ssd_keras/weights_SSD300.hdf5') self.bbox_util = BBoxUtility(self.num_classes) self.conf_thresh = 0.25 self.model._make_predict_function() self.graph = tf.get_default_graph() self.detection_index = DL_msgs_boxes() # Create unique and somewhat visually distinguishable bright # colors for the different classes. self.class_colors = [] for i in range(0, self.num_classes): # This can probably be written in a more elegant manner hue = 255 * i / self.num_classes col = np.zeros((1, 1, 3)).astype("uint8") col[0][0][0] = hue col[0][0][1] = 128 # Saturation col[0][0][2] = 255 # Value cvcol = cv2.cvtColor(col, cv2.COLOR_HSV2BGR) col = (int(cvcol[0][0][0]), int(cvcol[0][0][1]), int(cvcol[0][0][2])) self.class_colors.append(col) self.bridge = CvBridge() # Create the cv_bridge object self.Image_Status = "Not_Ready" self.StartImage = cv2.imread(pkg_path + '/resources/start.jpg') self.to_draw = cv2.resize(self.StartImage, (640, 480)) self.image_sub = rospy.Subscriber( "/floating_sensor/camera/rgb/image_raw", Image, self.detect_image, queue_size=1) # the appropriate callbacks self.box_coordinate_pub = rospy.Publisher( "/ssd_detction/box", DL_msgs_boxes, queue_size=5) # the appropriate callbacks self.SSD_Serv = rospy.Service('SSD_Detection', DL_box, self.SSD_Detection_Server)
def __init__(self): #TODO load classifier NUM_CLASSES = 3 + 1 input_shape = (300, 300, 3) # "prior boxes" in the paper priors = pickle.load(open('prior_boxes_ssd300.pkl', 'rb')) self.bbox_util = BBoxUtility(NUM_CLASSES, priors) self.model = SSD300(input_shape, num_classes=NUM_CLASSES) self.model.load_weights('weights.180314.hdf5', by_name=True)
def __init__(self): self.image_width = 300 self.image_height = 300 self.voc_classes = [ 'Aeroplane', 'Bicycle', 'Bird', 'Boat', 'Bottle', 'Bus', 'Car', 'Cat', 'Chair', 'Cow', 'Diningtable', 'Dog', 'Horse', 'Motorbike', 'Person', 'Pottedplant', 'Sheep', 'Sofa', 'Train', 'Tvmonitor' ] self.NUM_CLASSES = len(self.voc_classes) + 1 self.model = SSD300((self.image_height, self.image_width, 3), num_classes=self.NUM_CLASSES) self.model.load_weights('weights_SSD300.hdf5', by_name=True) self.bbox_util = BBoxUtility(self.NUM_CLASSES)
def init_model(weight_file='ssd_keras/SSD/weights_SSD300.hdf5'): np.set_printoptions(suppress=True) config = tf.ConfigProto() config.gpu_options.per_process_gpu_memory_fraction = 0.45 set_session(tf.Session(config=config)) NUM_CLASSES = len(voc_classes) + 1 input_shape = (300, 300, 3) model = SSD300(input_shape, num_classes=NUM_CLASSES) model.load_weights(weight_file, by_name=True) bbox_util = BBoxUtility(NUM_CLASSES) return model, bbox_util
def __init__(self, conf_limit=0.6): self.conf_limit = conf_limit np.set_printoptions(suppress=True) config = tf.ConfigProto() #config.gpu_options.per_process_gpu_memory_fraction = 0.45 set_session(tf.Session(config=config)) self.voc_classes = [ 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor' ] NUM_CLASSES = len(self.voc_classes) + 1 self.bbox_util = BBoxUtility(NUM_CLASSES) input_shape = (300, 300, 3) self.model = SSD300(input_shape, num_classes=NUM_CLASSES) self.model.load_weights('weights_SSD300.hdf5', by_name=True)
def get_model(name, experiment, input_shape, num_classes=6, verbose=True): """ Gets an SSD model, with trained weights Arguments: name -- name of the dataset experiment -- name of this training run input_shape -- size of images fed to SSD as a tuple like (640,480,3) num_classes -- the number of different object classes (including background) """ model = SSD300((input_shape[1], input_shape[0], input_shape[2]), num_classes=num_classes) weights_files = list((runs_path / "{}_{}".format(name, experiment) / "checkpoints").glob('*.hdf5')) weights_files_loss = np.array( [float(wf.stem.split('-')[-1]) for wf in weights_files]) weights_file = weights_files[np.argmin(weights_files_loss)] model.load_weights(weights_file, by_name=True) if verbose: print_flush('Model loaded from {}'.format(weights_file)) return model
def __init__( self, path_weights="/home/francisco/git/ssd_keras/weights_SSD300.hdf5"): config = tf.ConfigProto() config.gpu_options.per_process_gpu_memory_fraction = 0.45 set_session(tf.Session(config=config)) self.labels = [ 'Aeroplane', 'Bicycle', 'Bird', 'Boat', 'Bottle', 'Bus', 'Car', 'Cat', 'Chair', 'Cow', 'Diningtable', 'Dog', 'Horse', 'Motorbike', 'Person', 'Pottedplant', 'Sheep', 'Sofa', 'Train', 'Tvmonitor' ] NUM_CLASSES = len(self.labels) + 1 input_shape = (300, 300, 3) # Get detections with confidence higher than 0.6. self.detection_confidence = 0.6 self.model = SSD300(input_shape, num_classes=NUM_CLASSES) self.model.load_weights(path_weights, by_name=True) self.bbox_util = BBoxUtility(NUM_CLASSES) self.detections = []
def predict_img(numpy_array, orig_numpy_array): # Save the original image for attachment scipy.misc.imsave('temp_cat_water.jpg', np.uint8(orig_numpy_array)) # Number of voc_classes + 1 NUM_CLASSES = 3 input_shape = (300, 300, 3) # SSD model model = SSD300(input_shape, num_classes=NUM_CLASSES) model.load_weights('./model/weights.18-0.09.hdf5', by_name=True) bbox_util = BBoxUtility(NUM_CLASSES) # Inception v3 transfer learning model model_cnn = load_model(filepath='./model/model_v2.03-0.40.hdf5') ssd_img_size = 300 img_size = 299 inputs = [] images = [] images.append(orig_numpy_array) inputs.append(numpy_array.copy()) inputs = preprocess_input(np.array(inputs)) preds = model.predict(inputs, batch_size=1, verbose=0) results = bbox_util.detection_out(preds) # If the SSD model does not find an appropriate object, automatically return 0.00 for i, img in enumerate(images): if type(results[i]) is not list: ssd_img = ssd_image(img, results, i) resize_img = imresize(ssd_img, (img_size, img_size)) x = np.expand_dims(resize_img, axis=0) y_pred = model_cnn.predict(x) prediction = round(y_pred[0][0], 3) else: prediction = 0.00 return prediction
def convertToModel(path): vgg = torch.load('./raw_pretrain/pretrain_selectedtotrain.pth') vgg = vgg['net'] #print(vgg.keys()) ssd_net = SSD300() layer_indices = [ 0, 1, 3, 4, 7, 8, 10, 11, 14, 15, 17, 18, 20, 21, 24, 25, 27, 28, 30, 31 ] #,24,25,27,28,30,31] prefix = 'module.' for layer_idx in layer_indices: ssd_net.base[layer_idx].weight.data = vgg[prefix + 'features.%d.weight' % layer_idx] ssd_net.base[layer_idx].bias.data = vgg[prefix + 'features.%d.bias' % layer_idx] # [24,26,28] ssd_net.conv5_1.weight.data = vgg[prefix + 'features.34.weight'] ssd_net.conv5_1.bias.data = vgg[prefix + 'features.34.bias'] ssd_net.conv5_2.weight.data = vgg[prefix + 'features.37.weight'] ssd_net.conv5_2.bias.data = vgg[prefix + 'features.37.bias'] ssd_net.conv5_3.weight.data = vgg[prefix + 'features.40.weight'] ssd_net.conv5_3.bias.data = vgg[prefix + 'features.40.bias'] ssd_net.norm5_1.weight.data = vgg[prefix + 'features.35.weight'] ssd_net.norm5_1.bias.data = vgg[prefix + 'features.35.bias'] ssd_net.norm5_2.weight.data = vgg[prefix + 'features.38.weight'] ssd_net.norm5_2.bias.data = vgg[prefix + 'features.38.bias'] ssd_net.norm5_3.weight.data = vgg[prefix + 'features.41.weight'] ssd_net.norm5_3.bias.data = vgg[prefix + 'features.41.bias'] torch.save(ssd_net.state_dict(), path)
def main(img_paths): """ Detect objects in images. Parameters ---------- img_paths : list of strings """ # Load the model voc_classes = [ 'Aeroplane', 'Bicycle', 'Bird', 'Boat', 'Bottle', 'Bus', 'Car', 'Cat', 'Chair', 'Cow', 'Diningtable', 'Dog', 'Horse', 'Motorbike', 'Person', 'Pottedplant', 'Sheep', 'Sofa', 'Train', 'Tvmonitor' ] NUM_CLASSES = len(voc_classes) + 1 input_shape = (300, 300, 3) model = SSD300(input_shape, num_classes=NUM_CLASSES) model.load_weights('weights_SSD300.hdf5', by_name=True) bbox_util = BBoxUtility(NUM_CLASSES) # Load the inputs inputs = [] images = [] for img_path in img_paths: img = image.load_img(img_path, target_size=(300, 300)) img = image.img_to_array(img) images.append(imread(img_path)) inputs.append(img.copy()) inputs = preprocess_input(np.array(inputs)) # Predict preds = model.predict(inputs, batch_size=1, verbose=1) results = bbox_util.detection_out(preds) # Visualize for i, img in enumerate(images): create_overlay(img, results[i], voc_classes, "{}-det.png".format(img_paths[i]))
def __init__(self): NUM_CLASSES = 3 + 1 input_shape = (300, 300, 3) config_string = rospy.get_param("/traffic_light_config") self.config = yaml.load(config_string) self.stop_line_positions = self.config['stop_line_positions'] # get path to resources path_to_resources = os.path.join( os.path.dirname(os.path.abspath(__file__)), '..', '..', '..', '..', 'tlc') # "prior boxes" in the paper priors = pickle.load( open(os.path.join(path_to_resources, 'prior_boxes_ssd300.pkl'), 'rb')) self.bbox_util = BBoxUtility(NUM_CLASSES, priors) # Traffic Light Classifier model and its weights self.model = SSD300(input_shape, num_classes=NUM_CLASSES) print(self.model.summary()) self.model.load_weights(os.path.join( path_to_resources, self.config['classifier_weights_file']), by_name=True) # prevent TensorFlow's ValueError when no raised backend dummy = np.zeros((1, 300, 300, 3)) _ = self.model.predict(dummy, batch_size=1, verbose=0) # prevent TensorFlow's ValueError when no raised backend dummy = np.zeros((1, 300, 300, 3)) _ = self.model.predict(dummy, batch_size=1, verbose=0) self.capture_images = False self.image_counts = {0: 0, 1: 0, 2: 0, 4: 0} self.last_classification = None
print("save " + plt_fname) if __name__ == "__main__": import glob imagesList = glob.glob("images/*.jpg") # Load the model voc_classes = [ 'Aeroplane', 'Bicycle', 'Bird', 'Boat', 'Bottle', 'Bus', 'Car', 'Cat', 'Chair', 'Cow', 'Diningtable', 'Dog', 'Horse', 'Motorbike', 'Person', 'Pottedplant', 'Sheep', 'Sofa', 'Train', 'Tvmonitor' ] NUM_CLASSES = len(voc_classes) + 1 input_shape = (300, 300, 3) model = SSD300(input_shape, num_classes=NUM_CLASSES) model.load_weights('weights_SSD300.hdf5', by_name=True) bbox_util = BBoxUtility(NUM_CLASSES) # Load the inputs inputs = [] images = [] for img_path in imagesList: print("process " + img_path) img = image.load_img(img_path, target_size=(300, 300)) img = image.img_to_array(img) images.append(imread(img_path)) inputs.append(img.copy()) # 前置處理 print("前置處理...") inputs = preprocess_input(np.array(inputs))
from ssd import SSD300, SSD512 from utils.caffe2keras import add_missing_layers model = SSD300((300, 300, 3), num_classes=21) add_missing_layers(model, 'ssd300_voc_weights.hdf5', 'ssd300_voc_weights_fixed.hdf5') model = SSD512((512, 512, 3), num_classes=21) add_missing_layers(model, 'ssd512_voc_weights.hdf5', 'ssd512_voc_weights_fixed.hdf5')
if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('model') parser.add_argument('image') args = parser.parse_args() size = 300 multibox_encoder = MultiBoxEncoder( n_scale=6, variance=(0.1, 0.2), grids=(38, 19, 10, 5, 3, 1), aspect_ratios=((2,), (2, 3), (2, 3), (2, 3), (2,), (2,))) model = SSD300( n_class=20, n_anchors=multibox_encoder.n_anchors) serializers.load_npz(args.model, model) src = cv2.imread(args.image, cv2.IMREAD_COLOR) x = cv2.resize(src, (size, size)).astype(np.float32) x -= (103.939, 116.779, 123.68) x = x.transpose(2, 0, 1) x = x[np.newaxis] loc, conf = model(x) boxes, conf = multibox_encoder.decode(loc.data[0], conf.data[0]) conf = conf[:, 1:] img = src.copy()
'''Convert pretrained VGG model to SSD. VGG model download from PyTorch model zoo: https://download.pytorch.org/models/vgg16-397923af.pth ''' import torch from ssd import SSD300 vgg = torch.load('./model/vgg16-397923af.pth') ssd = SSD300() layer_indices = [0, 2, 5, 7, 10, 12, 14, 17, 19, 21] for layer_idx in layer_indices: ssd.base[layer_idx].weight.data = vgg['features.%d.weight' % layer_idx] ssd.base[layer_idx].bias.data = vgg['features.%d.bias' % layer_idx] # [24,26,28] ssd.conv5_1.weight.data = vgg['features.24.weight'] ssd.conv5_1.bias.data = vgg['features.24.bias'] ssd.conv5_2.weight.data = vgg['features.26.weight'] ssd.conv5_2.bias.data = vgg['features.26.bias'] ssd.conv5_3.weight.data = vgg['features.28.weight'] ssd.conv5_3.bias.data = vgg['features.28.bias'] for k in ssd.state_dict(): print(k) torch.save(ssd.state_dict(), 'model/ssd.pth')
from chainer import serializers from chainer.links.caffe import CaffeFunction import config from ssd import SSD300 if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('source') parser.add_argument('target') parser.add_argument('--baseonly', action='store_true') parser.set_defaults(baseonly=False) args = parser.parse_args() caffe_model = CaffeFunction(args.source) model = SSD300(n_class=20, aspect_ratios=config.aspect_ratios) model.base.conv1_1.copyparams(caffe_model.conv1_1) model.base.conv1_2.copyparams(caffe_model.conv1_2) model.base.conv2_1.copyparams(caffe_model.conv2_1) model.base.conv2_2.copyparams(caffe_model.conv2_2) model.base.conv3_1.copyparams(caffe_model.conv3_1) model.base.conv3_2.copyparams(caffe_model.conv3_2) model.base.conv3_3.copyparams(caffe_model.conv3_3) model.base.conv4_1.copyparams(caffe_model.conv4_1) model.base.conv4_2.copyparams(caffe_model.conv4_2) model.base.conv4_3.copyparams(caffe_model.conv4_3)
def train(NUM_CLASSES, nb_epoch, base_lr=3e-4, path_prefix='data/train/', dev="cpu"): import keras import tensorflow as tf from keras.backend.tensorflow_backend import set_session import os import matplotlib.pyplot as plt import numpy as np import pickle from sklearn.model_selection import train_test_split from ssd import SSD300 from ssd_training import MultiboxLoss from ssd_training import Generator from ssd_utils import BBoxUtility from keras.callbacks import TensorBoard plt.rcParams['figure.figsize'] = (8, 8) plt.rcParams['image.interpolation'] = 'nearest' np.set_printoptions(suppress=True) if dev == "cpu": os.environ['CUDA_VISIBLE_DEVICES'] = '-1' # for multi GPUs else: os.environ['CUDA_VISIBLE_DEVICES'] = '0' config = tf.ConfigProto() config.gpu_options.per_process_gpu_memory_fraction = 0.9 set_session(tf.Session(config=config)) # some constants NUM_CLASSES = NUM_CLASSES + 1 # 1 means mask input_shape = (300, 300, 3) # nb_epoch = 5 # base_lr = 3e-4 # path_prefix = 'data/train/' # path to your data priors = pickle.load(open('data/prior_boxes_ssd300.pkl', 'rb')) bbox_util = BBoxUtility(NUM_CLASSES, priors) gt = pickle.load(open('data/train.pkl', 'rb'), encoding='iso-8859-1') # for python3.x lable = pickle.load(open('data/label.pkl', 'rb'), encoding='iso-8859-1') # for python3.x # gt = pickle.load(open('data_convert/train.pkl', 'rb')) # keys = sorted(gt.keys()) # num_train = int(round(0.85 * len(keys))) # train_keys = keys[:num_train] # val_keys = keys[num_train:] # num_val = len(val_keys) train_keys, val_keys, train_label, val_label = train_test_split(sorted(lable.keys()), sorted(lable.values()), test_size=0.1, random_state=0) num_train = len(train_keys) num_val = len(val_keys) print(train_keys) print(val_keys) gen = Generator(gt, bbox_util, 1, path_prefix, train_keys, val_keys, (input_shape[0], input_shape[1]), do_crop=False) model = SSD300(input_shape, num_classes=NUM_CLASSES) model.load_weights('data/weights_SSD300.hdf5', by_name=True) freeze = ['input_1', 'conv1_1', 'conv1_2', 'pool1', 'conv2_1', 'conv2_2', 'pool2', 'conv3_1', 'conv3_2', 'conv3_3', 'pool3',] # 'conv4_1', 'conv4_2', 'conv4_3', 'pool4'] # freeze = ['input_1', 'conv1_1', 'conv1_2', 'pool1', # 'conv2_1', 'conv2_2', 'pool2', # 'conv3_1', 'conv3_2', 'conv3_3', 'pool3', # 'conv4_1', 'conv4_2', 'conv4_3', 'pool4', 'conv4_3_norm', # 'conv5_1', 'conv5_2', 'conv5_3', 'pool5', 'fc6', 'fc7', # 'conv6_1', 'conv6_2', # 'conv7_1', 'conv7_1z', 'conv7_2', # 'conv8_1', 'conv8_2', # 'pool6' # ] for L in model.layers: if L.name in freeze: L.trainable = False def schedule(epoch, decay=0.9): return base_lr * decay ** (epoch) # checkpoints/weights.{epoch:02d}-{val_loss:.2f}.hdf5 callbacks = [keras.callbacks.ModelCheckpoint('checkpoints/weights.hdf5', verbose=1, save_weights_only=True, save_best_only=True, mode='auto', period=1), keras.callbacks.LearningRateScheduler(schedule),TensorBoard(log_dir='logs')] optim = keras.optimizers.Adam(lr=base_lr) # optim = keras.optimizers.RMSprop(lr=base_lr) # optim = keras.optimizers.SGD(lr=base_lr, momentum=0.9, decay=decay, nesterov=True) model.compile(optimizer=optim, loss=MultiboxLoss(NUM_CLASSES, neg_pos_ratio=2.0).compute_loss) a=0 history = model.fit_generator(gen.generate(True), steps_per_epoch=num_train, epochs=nb_epoch, verbose=1, callbacks=callbacks, validation_data=gen.generate(False), validation_steps=num_val, nb_worker=1)
cv2.imshow("SSD result", orig_image) if cv2.waitKey(5) & 0xFF == ord('s'): if len(image_stack) == frame_number: if not os.path.exists(save_path + str(sample_count + 1)): os.mkdir(save_path + str(sample_count + 1)) for pic in range(frame_number): cv2.imwrite( save_path + str(sample_count + 1) + '/' + str(1000 + pic) + '.jpg', image_stack[pic]) print('saving ' + save_path + str(sample_count + 1) + '/' + str(1000 + pic) + '.jpg') image_stack = [] empty_count = 0 sample_count += 1 if __name__ == '__main__': action_class = 'stand/' root_path = 'images/' save_path = root_path + action_class if not os.path.exists(root_path): os.mkdir(root_path) if not os.path.exists(save_path): os.mkdir(save_path) save_frames = 16 input_shape = (300, 300, 3) ssd_model = SSD(input_shape, num_classes=21) ssd_model.load_weights('weights_SSD300.hdf5') run_camera(input_shape, ssd_model, save_path, save_frames)
class ssdKeras(): def __init__(self): #self.node_name = "ssd_keras" #rospy.init_node(self.node_name) self.class_names = ["background", "aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor"] self.num_classes = len(self.class_names) self.input_shape = (300,300,3) self.model = SSD(self.input_shape,num_classes=self.num_classes) self.model.load_weights('/home/abdulrahman/catkin_ws/src/victim_localization/resources/ssd_keras/weights_SSD300.hdf5') self.bbox_util = BBoxUtility(self.num_classes) self.conf_thresh = 0.7 self.model._make_predict_function() self.graph = tf.get_default_graph() self.detection_index=DL_msgs_boxes() # Create unique and somewhat visually distinguishable bright # colors for the different classes. self.class_colors = [] for i in range(0, self.num_classes): # This can probably be written in a more elegant manner hue = 255*i/self.num_classes col = np.zeros((1,1,3)).astype("uint8") col[0][0][0] = hue col[0][0][1] = 128 # Saturation col[0][0][2] = 255 # Value cvcol = cv2.cvtColor(col, cv2.COLOR_HSV2BGR) col = (int(cvcol[0][0][0]), int(cvcol[0][0][1]), int(cvcol[0][0][2])) self.class_colors.append(col) self.bridge = CvBridge() # Create the cv_bridge object self.image_sub = rospy.Subscriber("/image_raw_converted2", Image, self.detect_image,queue_size=1) # the appropriate callbacks self.box_coordinate_pub = rospy.Publisher("/ssd_detction/box", DL_msgs_boxes ,queue_size=5) # the appropriate callbacks def detect_image(self, ros_image): """ Runs the test on a video (or webcam) # Arguments conf_thresh: Threshold of confidence. Any boxes with lower confidence are not visualized. """ #### Use cv_bridge() to convert the ROS image to OpenCV format #### try: image_orig = self.bridge.imgmsg_to_cv2(ros_image, "bgr8") except CvBridgeError as e: print(e) ########## vidw = 1280.0 # change from cv2.cv.CV_CAP_PROP_FRAME_WIDTH vidh = 720.0 # change from cv2.cv.CV_CAP_PROP_FRAME_HEIGHT vidar = vidw/vidh #print(type(image_orig)) im_size = (self.input_shape[0], self.input_shape[1]) resized = cv2.resize(image_orig, im_size) rgb = cv2.cvtColor(resized, cv2.COLOR_BGR2RGB) # Reshape to original aspect ratio for later visualization # The resized version is used, to visualize what kind of resolution # the network has to work with. to_draw = cv2.resize(resized, (1280, 720)) # Use model to predict inputs = [image.img_to_array(rgb)] tmp_inp = np.array(inputs) x = preprocess_input(tmp_inp) start_time = time.time() #debuggin with self.graph.as_default(): y = self.model.predict(x) #print("--- %s seconds_for_one_image ---" % (time.time() - start_time)) # This line creates a new TensorFlow device every time. Is there a # way to avoid that? results = self.bbox_util.detection_out(y) if len(results) > 0 and len(results[0]) > 0: # Interpret output, only one frame is used det_label = results[0][:, 0] det_conf = results[0][:, 1] det_xmin = results[0][:, 2] det_ymin = results[0][:, 3] det_xmax = results[0][:, 4] det_ymax = results[0][:, 5] top_indices = [i for i, conf in enumerate(det_conf) if conf >= self.conf_thresh] top_conf = det_conf[top_indices] top_label_indices = det_label[top_indices].tolist() top_xmin = det_xmin[top_indices] top_ymin = det_ymin[top_indices] top_xmax = det_xmax[top_indices] top_ymax = det_ymax[top_indices] #initiaze the detection msgs box_msg = DL_msgs_box() box_msg.xmin=0 box_msg.ymin=0 box_msg.xmax=0 box_msg.ymax=0 box_msg.Class="Non" # 100 reflect a non-class value self.detection_index.boxes.append(box_msg) print (top_xmin) for i in range(top_conf.shape[0]): self.detection_index.boxes[:]=[] xmin = int(round(top_xmin[i] * to_draw.shape[1])) ymin = int(round(top_ymin[i] * to_draw.shape[0])) xmax = int(round(top_xmax[i] * to_draw.shape[1])) ymax = int(round(top_ymax[i] * to_draw.shape[0])) #include the corner to be published box_msg = DL_msgs_box() box_msg.xmin=xmin box_msg.ymin=ymin box_msg.xmax=xmax box_msg.ymax=ymax box_msg.Class=self.class_names[int(top_label_indices[i])] self.detection_index.boxes.append(box_msg) # Draw the box on top of the to_draw image class_num = int(top_label_indices[i]) if (self.class_names[class_num]=="person"): cv2.rectangle(to_draw, (xmin, ymin), (xmax, ymax), self.class_colors[class_num], 2) text = self.class_names[class_num] + " " + ('%.2f' % top_conf[i]) text_top = (xmin, ymin-10) text_bot = (xmin + 80, ymin + 5) text_pos = (xmin + 5, ymin) cv2.rectangle(to_draw, text_top, text_bot, self.class_colors[class_num], -1) cv2.putText(to_draw, text, text_pos, cv2.FONT_HERSHEY_SIMPLEX, 0.35, (0,0,0), 1) #cv2.circle(to_draw, (xmax, ymax),1,self.class_colors[class_num],30); self.detection_index.header = std_msgs.msg.Header() self.detection_index.header.stamp=rospy.Time.now() print (self.detection_index) self.box_coordinate_pub.publish(self.detection_index) self.detection_index.boxes[:]=[] #self.detection_index.boxes.clear() cv2.imshow("SSD result", to_draw) cv2.waitKey(1) def main(self): rospy.spin()
import torch import torchvision import torch.nn.functional as F import torchvision.transforms as transforms import os from torch.autograd import Variable import numpy as np from ssd import SSD300 from encoder import DataEncoder from PIL import Image, ImageDraw import torch.backends.cudnn as cudnn use_cuda = torch.cuda.is_available() # Load model net = SSD300() #net = net.cuda() # for gpu checkpoint = torch.load('/media/biometric/Data1/Ranjeet/NewPytorch/SSD_Ear_RGB_300/Model/Model_Cropped.pth') net.load_state_dict(checkpoint['net']) net.eval() if use_cuda: print("Gpu is available") net = torch.nn.DataParallel(net, device_ids=[0]) net.cuda() cudnn.benchmark = True # Load test image list_image = os.listdir('/media/biometric/Data1/Ranjeet/NewPytorch/Challenge_images') for image in list_image:
import keras import pickle from videotest import VideoTest import sys sys.path.append("..") from ssd import SSD300 as SSD input_shape = (300, 300, 3) # Change this if you run with other classes than VOC class_names = [ "background", "aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor" ] NUM_CLASSES = len(class_names) model = SSD(input_shape, num_classes=NUM_CLASSES) # Change this path if you want to use your own trained weights model.load_weights('./checkpoints/weights.200-3.67.hdf5') vid_test = VideoTest(class_names, model, input_shape) # To test on webcam 0, remove the parameter (or change it to another number # to test on that webcam) vid_test.run()
pickle.dump(all_boxes, f, pickle.HIGHEST_PROTOCOL) print('Evaluating detections') evaluate_detections(all_boxes, output_dir, dataset) def evaluate_detections(box_list, output_dir, dataset): write_voc_results_file(box_list, dataset) do_python_eval(output_dir) if __name__ == '__main__': # load net num_classes = len(VOC_CLASSES) + 1 # +1 background #net = build_ssd('test', 300, num_classes) # initialize SSD net = SSD300(num_classes, 'test') net.load_state_dict(torch.load(args.trained_model)) net.eval() print('Finished loading model!') # load data dataset = VOCDetection(args.voc_root, [('2007', set_type)], BaseTransform(300, dataset_mean), AnnotationTransform()) if args.cuda: net = net.cuda() cudnn.benchmark = True # evaluation test_net(args.save_folder, net, args.cuda, dataset,
import keras import pickle from videotest import VideoTest import sys sys.path.append("..") from ssd import SSD300 as SSD input_shape = (300,300,3) # Change this if you run with other classes than VOC class_names = ["background", "aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor"]; NUM_CLASSES = len(class_names) model = SSD(input_shape, num_classes=NUM_CLASSES) # Change this path if you want to use your own trained weights model.load_weights('../weights_SSD300.hdf5') vid_test = VideoTest(class_names, model, input_shape) # To test on webcam 0, remove the parameter (or change it to another number # to test on that webcam) vid_test.run('path/to/your/video.mkv')
import keras import pickle from videotest import VideoTest import sys sys.path.append("..") from ssd import SSD300 as SSD input_shape = (300, 300, 3) # Change this if you run with other classes than VOC class_names = [ "background", "dog", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor" ] NUM_CLASSES = len(class_names) model = SSD(input_shape, num_classes=NUM_CLASSES) # Change this path if you want to use your own trained weights model.load_weights('../weights_SSD300.hdf5') vid_test = VideoTest(class_names, model, input_shape) # To test on webcam 0, remove the parameter (or change it to another number # to test on that webcam) vid_test.run('path/to/your/video.mkv')
def get_anchor_boxes(): model = SSD300(1) return model.anchors
from ssd import SSD300 from ssd_utils import BBoxUtility from ssd_training import MultiboxLoss from pycocotools.coco import COCO import numpy as np from scipy.misc import imread from scipy.misc import imresize import pickle model = SSD300(num_classes=81) mbLoss = MultiboxLoss(num_classes=81) model.compile(loss=mbLoss.compute_loss, optimizer='adam') ssd300_priors = pickle.load(open('prior_boxes_ssd300.pkl')) bboxer = BBoxUtility(num_classes=81, priors=ssd300_priors) cocodata = COCO('/DATA/COCO/annotations/instances_train2017.json') cocoDir = '/DATA/COCO/train2017/' catsToIds = {} for i, catid in enumerate(cocodata.getCatIds()): catsToIds[catid] = i def generator(batch_size=4): imgList = cocodata.imgs.keys() imgcount = len(imgList) n = 0 while True: X = np.zeros((batch_size, 300, 300, 3), dtype=np.float)