def __init__(self, dataset_name, mode): self.mode = mode if isinstance(dataset_name, list): self.images = [[], []] for sub_name in dataset_name: image_A, image_B = load_images( os.path.join(dataset_dir, sub_name), mode, sub_name in ["facades", "cityscapes"]) self.images[0].extend(image_A) self.images[1].extend(image_B) images = list(zip(self.images[0], self.images[1])) np.random.shuffle(images) self.images[0], self.images[1] = zip(*images) else: self.images = load_images( os.path.join(dataset_dir, dataset_name), mode, dataset_name in ["facades", "cityscapes"])
def main(): '''Declares variables, loads images, loads the game map, and starts the game loop.''' global FPSCLOCK FPSCLOCK = pygame.time.Clock() # “mouse” is the position of the mouse cursor. # “left clicked”, “left mouse down”, “right clicked” and “right # mouse down” are all about the mouse buttons. # “key up” is when a general character key of the keyboard was # pressed. # “shift” is when shift is down. # “arrow key up” is when an arrow key has been pressed. player_input = {'mouse':(0, 0), 'left clicked': False, 'left mouse down':False, 'right clicked':False, 'right mouse down':False, 'key up':None, 'shift':False, 'arrow key up': None} gui.set_mode() pygame.display.set_caption('Sociétés') start_load = time() images_loaded = loader.load_images() print('Images loaded! Time spent:{}'.format(time() - start_load)) map_ = world.Map() # game map print('Map instanced! Time spent: {}'.format(time() - start_load)) world_time = world.Time() # what time is it? # list of nomad groups on the game map list_of_nomad_groups = humans.place_test_stuff() event.set_allowed() dialog_box = gui.DialogBox() main_loop(player_input, images_loaded, map_, world_time, list_of_nomad_groups, dialog_box)
clf.fit(x_train, y_train) score = clf.score(x_test, y_test) # y_pred = clf.predict(x_test) # accuracy = sum([y_pred[i] == y_test[i] for i in range(len(y_test))]) / len(y_test) print('the score of {}--{} is {}'.format(kernel, C, str(score))) if __name__ == '__main__': param_config = InceptionModel() if not os.listdir(param_config.DEST_PATH): augment.ImageGen(param_config.PATH, param_config.DEST_PATH).gen_image() print("generate images end...") data_set = loader.load_images(param_config.DEST_PATH) X = [data[0] for data in data_set] Y = [data[1] for data in data_set] features = extract_features(param_config.MODEL_PATH, X, param_config.PICKLE_X_FILE) # 使用label会报错,svm中y值不能是one-hot形式 x_train, x_test, y_train, y_test = train_test_split(features, Y, test_size=0.1, random_state=0) # 从2048维度降到200 n_components = 200 pca = PCA(n_components=n_components).fit(x_train) x_train_pca = pca.transform(x_train) x_test_pca = pca.transform(x_test) param_grid = {
def test_load_image_kvs(self): loader.load_images(self.kvs, self.image_iterator) for key, value in self.image_iterator: self.assertItemsEqual(self.kvs.get(key), [value])
import loader import config from scipy.misc import imread import matplotlib.pyplot as plt import seaborn as sns base_config = config.BaseConfig data_set = loader.load_images(base_config.PATH) def plt_images_size(): images_size = {} for data in data_set: image_array = imread(data[0]) size = "*".join(map(str, list(image_array.shape))) images_size[size] = images_size.get(size, 0) + 1 plt.figure(figsize=(12, 4)) sns.barplot(list(images_size.keys()), list(images_size.values()), alpha=0.8) plt.xlabel("image size", fontsize=12) plt.ylabel("number of images", fontsize=12) plt.title("images size present in dataset") plt.savefig('./data/image/images-size-proportion.jpg') plt_images_size()
def detection_loop(args, num_classes): write = 0 CUDA = torch.cuda.is_available() model = load_network(args) inp_dim = int(model.net_info["height"]) imlist, im_batches, im_dim_list, loaded_ims, read_dir, load_batch = load_images( args, inp_dim) start_det_loop = time.time() output_recast = 0 for i, batch in enumerate(im_batches): # load the image start = time.time() with torch.no_grad(): prediction = model(Variable(batch).cuda(), CUDA) prediction = write_results(prediction, float(args.confidence), num_classes, nms_conf=float(args.nms_thresh)) end = time.time() output_recast += end - start if type(prediction) == int: for im_num, image in enumerate( imlist[i * int(args.bs):min((i + 1) * int(args.bs), len(imlist))]): im_id = i * int(args.bs) + im_num print("{0:20s} predicted in {1:6.3f} seconds".format( image.split("/")[-1], (end - start) / int(args.bs))) print("{0:20s} {1:s}".format("Objects Detected:", "")) print( "----------------------------------------------------------" ) continue prediction[:, 0] += i * args.bs # transform the atribute from index in batch to index in imlist if not write: # If we have't initialised output output = prediction write = 1 else: output = torch.cat((output, prediction)) for im_num, image in enumerate( imlist[i * args.bs:min((i + 1) * args.bs, len(imlist))]): im_id = i * args.bs + im_num objs = [classes[int(x[-1])] for x in output if int(x[0]) == im_id] print("{0:20s} predicted in {1:6.3f} seconds".format( image.split("/")[-1], (end - start) / args.bs)) print("{0:20s} {1:s}".format("Objects Detected:", " ".join(objs))) print("----------------------------------------------------------") if CUDA: torch.cuda.synchronize() try: output except NameError: print("No detections were made") exit() im_dim_list = torch.index_select(im_dim_list, 0, output[:, 0].long()) scaling_factor = torch.min(inp_dim / im_dim_list, 1)[0].view(-1, 1) output[:, [1, 3]] -= (inp_dim - scaling_factor * im_dim_list[:, 0].view(-1, 1)) / 2 output[:, [2, 4]] -= (inp_dim - scaling_factor * im_dim_list[:, 1].view(-1, 1)) / 2 output[:, 1:5] /= scaling_factor for i in range(output.shape[0]): output[i, [1, 3]] = torch.clamp(output[i, [1, 3]], 0.0, im_dim_list[i, 0]) output[i, [2, 4]] = torch.clamp(output[i, [2, 4]], 0.0, im_dim_list[i, 1]) class_load = time.time() colors = pkl.load(open("data/pallete", "rb")) draw = time.time() def Write(x, results, color): c1 = tuple(x[1:3].int()) c2 = tuple(x[3:5].int()) img = results[int(x[0])] cls = int(x[-1]) label = "{0}".format(classes[cls]) cv2.rectangle(img, c1, c2, color[cls], 1) t_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_PLAIN, 1, 1)[0] c2 = c1[0] + t_size[0] + 3, c1[1] + t_size[1] + 4 cv2.rectangle(img, c1, c2, color[cls], -1) cv2.putText(img, label, (c1[0], c1[1] + t_size[1] + 4), cv2.FONT_HERSHEY_PLAIN, 1, [225, 255, 255], 1) return img list(map(lambda x: Write(x, loaded_ims, colors), output)) det_names = pd.Series(imlist).apply( lambda x: "{}/det_{}".format(args.det, x.split("/")[-1])) list(map(cv2.imwrite, det_names, loaded_ims)) end = time.time() print("SUMMARY") print("----------------------------------------------------------") print("{:25s}: {}".format("Task", "Time Taken (in seconds)")) print() print("{:25s}: {:2.3f}".format("Reading addresses", load_batch - read_dir)) print("{:25s}: {:2.3f}".format("Loading batch", start_det_loop - load_batch)) print("{:25s}: {:2.3f}".format( "Detection (" + str(len(imlist)) + " images)", output_recast)) print("{:25s}: {:2.3f}".format("Output Processing", class_load - start_det_loop)) print("{:25s}: {:2.3f}".format("Drawing Boxes", end - draw)) print("{:25s}: {:2.3f}".format("Average time_per_img", (end - load_batch) / len(imlist))) print("----------------------------------------------------------") torch.cuda.empty_cache()
import loader import augment import tensorflow as tf from keras.preprocessing import image import matplotlib.pyplot as plt import numpy as np data_set = loader.load_images("../data/train/") class TestDataAug(tf.test.TestCase): def test_data_aug(self): img = image.load_img(data_set[0][0]) plt.imshow(img) plt.savefig("../data/image/origin.jpg") plt.show() x = image.img_to_array(img) x = np.expand_dims(x, axis=0) train_set = augment.DataGen(x, np.array([1]), batch_size=1) plt.figure() for i in range(3): for j in range(3): _x, y = train_set.next() idx = (3 * i) + j # plt.subplot(3, 3, idx + 1) plt.imshow(_x[0] / 256) plt.savefig('../data/image/{}-{}.jpg'.format(i, j)) plt.show()