def process_image(img, debug=False):
clf = classifier.get_classifier()
windows = search(img, clf)
heat_map = get_heat_map(img, windows)
heat_map = apply_threshold(heat_map, 1)
labeled_img = get_labeled_image(img, heat_map)
if debug:
import matplotlib.pyplot as plt
from sliding_window import draw_boxes
f, axarr = plt.subplots(2, 2, figsize=(15, 15))
axarr[0, 0].set_title('Original Image')
axarr[0, 0].imshow(img)
axarr[0, 1].set_title('Detected Windows')
axarr[0, 1].imshow(draw_boxes(img, windows))
axarr[1, 0].set_title('Heat Map')
axarr[1, 0].imshow(heat_map)
axarr[1, 1].set_title('Labeled Image')
axarr[1, 1].imshow(labeled_img)
plt.show()
return labeled_img
def run_algo(data, nb_class, hparam, argv):
""" Use Parambath et al. (2014) algorithm on given options """
# grid on t: covers all space with half a step at each extremity
t_values, step = np.linspace(argv.tmin,
argv.tmax,
argv.max_step,
endpoint=False,
retstep=True)
t_values = t_values + step / 2
outputs = {
"confusions": {
"train": np.zeros((argv.max_step, nb_class, nb_class), dtype=int),
"valid": np.zeros((argv.max_step, nb_class, nb_class), dtype=int),
"test": np.zeros((argv.max_step, nb_class, nb_class), dtype=int)
},
"predictions": {
"train":
np.zeros(
(argv.max_step, data["train"]["labels"].shape[0], nb_class),
dtype=np.float32),
"valid":
np.zeros(
(argv.max_step, data["valid"]["labels"].shape[0], nb_class),
dtype=np.float32),
"test":
np.zeros(
(argv.max_step, data["test"]["labels"].shape[0], nb_class),
dtype=np.float32)
},
"t_values": t_values
}
conf_mats = outputs["confusions"]
preds = outputs["predictions"]
for t_val_i, t_val in enumerate(t_values):
class_w = compute_weights(t_val, nb_class, argv.beta)
classif = classifier.get_classifier(argv, hparam, class_w)
classif.fit(data["train"]["exemples"], data["train"]["labels"])
for subset in ["train", "valid", "test"]:
out_iter = classifier.get_confusion(data, nb_class, subset,
classif)
if nb_class == 2:
conf_mats[subset][t_val_i], preds[subset][t_val_i, :,
0] = out_iter
else:
conf_mats[subset][t_val_i], preds[subset][t_val_i] = out_iter
return outputs
def run_algo(data, nb_class, hparam, argv):
""" Use baseline algorithm on given options """
outputs = {
"confusions": {
"train": np.zeros((1, nb_class, nb_class), dtype=int),
"valid": np.zeros((1, nb_class, nb_class), dtype=int),
"test": np.zeros((1, nb_class, nb_class), dtype=int)
},
"predictions": {
"train":
np.zeros((1, data["train"]["labels"].shape[0], nb_class),
dtype=np.float32),
"valid":
np.zeros((1, data["valid"]["labels"].shape[0], nb_class),
dtype=np.float32),
"test":
np.zeros((1, data["test"]["labels"].shape[0], nb_class),
dtype=np.float32)
},
"t_values": [-1]
}
conf_mats = outputs["confusions"]
preds = outputs["predictions"]
if argv.classif.lower() == "ir":
# class weight = 1 - <class proportion>
class_w = {
class_i: 1 - (data["train"]["labels"] == class_i).sum() /
data["train"]["labels"].shape[0]
for class_i in range(nb_class)
}
else:
class_w = {class_i: 1.0 for class_i in range(nb_class)}
classif = classifier.get_classifier(argv, hparam, class_w)
classif.fit(data["train"]["exemples"], data["train"]["labels"])
for subset in ["train", "valid", "test"]:
out_iter = classifier.get_confusion(data, nb_class, subset, classif)
if nb_class == 2:
conf_mats[subset][0], preds[subset][0, :, 0] = out_iter
else:
conf_mats[subset][0], preds[subset][0] = out_iter
return outputs
window_list.append(((x_start, y_start), (x_end, y_end)))
return window_list
def draw_boxes(img, bboxes, color=(0, 0, 255), thick=6):
"""Draw bounding boxes and return the image."""
imcopy = np.copy(img)
for bbox in bboxes:
cv2.rectangle(imcopy, bbox[0], bbox[1], color, thick)
return imcopy
if __name__ == '__main__':
import matplotlib.pyplot as plt
from skimage import io
fig, ax = plt.subplots(4, 2)
for i in range(0, 4):
for j in range(0, 2):
image = io.imread('test_images/test{}.jpg'.format(i * 2 + j + 1))
windows = multi_scale_windows(image)
windows = search_windows(image, windows,
classifier.get_classifier())
window_img = draw_boxes(image, windows, color=(0, 0, 255), thick=6)
ax[i, j].imshow(window_img)
plt.show()
else:
print ">> extract features"
features = fe.get_features(images,
hp.FeatureType.COL_BOW) # imgNum*featureLen
np.savetxt(fdir, features, delimiter=',')
print ">> features extracted"
##################################################
# FIT A CLASSIFIER USING RANDOM DATA
##################################################
all_data = train_ids
sampled_num = int(train_img_num * hp.sampling_ratio)
sampled_ids = all_data[:sampled_num]
lbs = [labels[x] for x in sampled_ids]
fts = [features[x] for x in sampled_ids]
classifier = cf.get_classifier(fts, lbs, hp.ClassifierType.RANDOM_FOREST)
print ">> fit classifier with %d labeled samples" % sampled_num
train_features = [features[x] for x in train_ids]
train_labels = [labels[x] for x in train_ids]
test_features = [features[x] for x in test_ids]
test_labels = [labels[x] for x in test_ids]
print "train", get_precision(classifier, train_features, train_labels)
print "test", get_precision(classifier, test_features, test_labels)
##################################################
# ACTIVE LEARNING / RANDOM SAMPLING
##################################################
useAL = True # use Active Learning or Random Sampling (when comparing AL with random sampling, do AL first)
comparePrecision = False # True when # of random sampling data = # of AL data
step = 0
def get_classifier():
global classifier_dft
if classifier_dft is None:
classifier_dft = classifier.get_classifier()
return classifier_dft
root.wm_title('Sentiment Analysis Application')
top_frame = Frame(root)
top_frame.pack()
bottom_frame = Frame(root)
bottom_frame.pack(side=BOTTOM)
l1 = Label(top_frame, text='Enter a review:')
l1.pack(side=LEFT)
w = Text(top_frame, height=3 )
w.pack(side=LEFT)
print("UI COMPLETE")
clf = get_classifier()
def main_op():
review_spirit = w.get('1.0',END)
demo = process(review_spirit)
print(demo)
demo1 = create_word_features(demo)
print(demo1)
demo2 = ('review is ' + clf.classify(demo1))
print(demo2)
l2 = Label(bottom_frame, text=demo2)
l2.pack()
button = Button(bottom_frame, text='Analyse', command=main_op )
button.pack(side=BOTTOM)
# print(df.shape)
#
# print(len(X))
# print(len(Y))
# X_res, Y_res = smote_sampling(X, Y)
#
X_test = df[X_columns].values.tolist()
Y_test = df[Y_columns].values.tolist()
# from collections import Counter
# print(Counter(Y_res))
X_res, Y_res = X, Y
clf = get_classifier('CSVM')
Y_list = list(map(lambda x: [x], Y_res))
clf.fit(X_res, Y_list)
test_clf(clf, X_test, Y_test)
# clf = get_classifier('CS')
# cost_mat = np.zeros((len(X_res), 4))
# 0 - tn, 1 - fp, 2 - fn, 3 - tp
# 00 tn
# 01 fp
# 10 fn
# 11 tp
# for each_y in Y_res:
# if each_y == 1:
# cost_mat[:, 0] = 1.5
# cost_mat[:, 1] = 0.5
def test_invalid_class_raises_key_error(self):
with self.assertRaises(KeyError):
classifier = get_classifier("invalid_class")
def test_invalid_spelling_raises_key_error(self):
with self.assertRaises(KeyError):
classifier = get_classifier("random_forestClassifier")
def test_valid_class_gives_expected(self):
classifier = get_classifier("RandomForestClassifier")
self.assertIsInstance(classifier, RandomForestClassifier)
args.training_set
)
if args.test_set:
training_set_numbers = training_set_numbers
test_set_parser = TestSetIO()
test_set_pixels = test_set_parser.parse(args.test_set)
else:
# Without a test set we need to split one out from the training set
training_set_pixels, test_set_pixels, training_set_numbers, \
test_set_numbers = train_test_split(
training_set_pixels, training_set_numbers, test_size=0.3
)
classifier = get_classifier(args.classifier)
classifier.train(training_set_numbers, training_set_pixels)
test_set_predicted_numbers = classifier.predict(test_set_pixels)
if args.test_set:
test_set_parser.write(test_set_predicted_numbers, stdout)
else:
print metrics.classification_report(
test_set_numbers,
test_set_predicted_numbers
)
if args.show_misclassified:
image_plotter = ImageDisplay()
print(
def get_classifier():
global classifier_dft
if classifier_dft is None:
classifier_dft = classifier.get_classifier()
return classifier_dft
with open('cat_to_name.json', 'r') as f:
cat_to_name = json.load(f)
model = model_load(pretrained=True)
# Remove gradient tracking from the network parameters
for param in model.parameters():
param.requires_grad = False
# Create a new classifier
# Use dropout probability that the VGG models use -
# authors likely knew what they were doing
classifier = get_classifier(features_count,
classifier_hidden=classifier_hidden,
dropout_p=0.5)
#Attach the new classifier (it has random weights now)
if classifier_name == 'classifier':
model.classifier = classifier
elif classifier_name == 'fc':
model.fc = classifier
# Move the model to GPU before constructing the optimizer
model.to(device)
# Set up negative likelihood loss and the adam optimizer
# (momentum is useful)
criterion = nn.NLLLoss()
if classifier_name == 'classifier':
parser.add_argument('--log',
default='classifier/logs/',
metavar='LOG',
help='path for recording training informtion')
parser.add_argument('--name',
default='mnist_lenet',
metavar='name',
help='specify a name for saving the model')
args = parser.parse_args()
# use cuda
use_cuda = torch.cuda.is_available()
# initialize model
model = get_classifier(args.classifier)
if use_cuda: model.cuda()
# get training, validation, and test dataset
dataset = mnist.IDEAL('./data', args.font)
train_size = len(dataset) - args.val_size - args.test_size
train_loader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
sampler=chunk.Chunk(train_size, 0))
val_loader = torch.utils.data.DataLoader(dataset,
batch_size=args.test_batch,
sampler=chunk.Chunk(
args.val_size, train_size))
zca_whitening=False,
rotation_range=0,
width_shift_range=0,
height_shift_range=0,
shear_range=0.,
zoom_range=0,
channel_shift_range=0.,
fill_mode='nearest',
cval=0.,
horizontal_flip=False,
vertical_flip=False,
rescale=None,
dim_ordering=K.image_dim_ordering())
#create classifier
classifier = clf.get_classifier(classifier_choice, input_shape=shape)
# define callbacks
# save intermediate training steps (every 50 batches)
inter = clf.EvaluateCallback(images_val[0], groundtruth_val[0], out_path = 'inter_test_image', verbose = False)
# save model instances with lowest validation loss
model_checkpoint = ModelCheckpoint('unet_weights.hdf5', monitor='val_loss', verbose =1, save_best_only=True, save_weights_only = True)
# early stop if validation loss does not significantly drop after 10 epochs. Saves time and
# avoids overfitting
early_stop = EarlyStopping(patience = 10)
# classifier.fit(images, groundtruth, batch_size = 16, validation_split = 0.1, nb_epoch=100, callbacks=[model_checkpoint, stef])
hist = classifier.fit_generator(train_gen.flow(images_train, groundtruth_train, batch_size=bs),
samples_per_epoch=2000,
nb_epoch=100,
validation_data = val_gen.flow(images_val, groundtruth_val),
nb_val_samples = len(images_val),
callbacks=[model_checkpoint, inter, early_stop])
# create features and assign class for each patch
#X_6d = np.asarray([hp.extract_features(img_patches[i]) for i in range(len(img_patches))])
X_2d = np.asarray(
[hp.extract_features_2d(img_patches[i]) for i in range(len(img_patches))])
Y = np.asarray([
hp.value_to_class(np.mean(gt_patches[i]), foreground_threshold)
for i in range(len(gt_patches))
])
# choose features to try
# features = np.load('features.npy') # np.load('features_full.npy')
# Y = np.load('labels.npy') #np.load('labels_full.npy')
features = X_2d
# create classifier
classifier = clf.get_classifier(classifier_choice)
# fit classifier
classifier.fit(X_2d, Y)
# cross validate
f1_scores = cross_val_score(classifier, features, Y, cv=k, scoring='f1')
print("F1-score: %0.2f (+/- %0.2f)" % (f1_scores.mean(), f1_scores.std() * 2))
# predict on single image and overlay
# idx = 1
# img_patches_test = hp.img_crop2(images[idx], patch_size, patch_size, overlap)
# X_2d_test = np.asarray([hp.extract_features_2d(img_patches_test[i]) for i in range(len(img_patches_test))])
# Y_est = classifier.predict(X_2d_test)
# h = groundtruth[idx].shape[0]
# w = groundtruth[idx].shape[1]
# predicted_img = hp.label_to_img(h, w, patch_size, patch_size, Y_est)
def main():
# Configs
args = get_args()
cfg = Config(args.config)
pose_kwargs = cfg.POSE
clf_kwargs = cfg.CLASSIFIER
tracker_kwargs = cfg.TRACKER
# Initiate video/webcam
source = args.source if args.source else 0
video = Video(source)
## Initiate trtpose, deepsort and action classifier
pose_estimator = get_pose_estimator(**pose_kwargs)
if args.task != 'pose':
tracker = get_tracker(**tracker_kwargs)
if args.task == 'action':
action_classifier = get_classifier(**clf_kwargs)
## initiate drawer and text for visualization
drawer = Drawer(draw_numbers=args.draw_kp_numbers)
user_text = {
'text_color': 'green',
'add_blank': True,
'Mode': args.task,
# MaxDist: cfg.TRACKER.max_dist,
# MaxIoU: cfg.TRACKER.max_iou_distance,
}
# loop over the video frames
for bgr_frame in video:
rgb_frame = cv2.cvtColor(bgr_frame, cv2.COLOR_BGR2RGB)
# predict pose estimation
start_pose = time.time()
predictions = pose_estimator.predict(rgb_frame, get_bbox=True) # return predictions which include keypoints in trtpose order, bboxes (x,y,w,h)
# if no keypoints, update tracker's memory and it's age
if len(predictions) == 0 and args.task != 'pose':
debug_img = bgr_frame
tracker.increment_ages()
else:
# draw keypoints only if task is 'pose'
if args.task != 'pose':
# Tracking
# start_track = time.time()
predictions = utils.convert_to_openpose_skeletons(predictions)
predictions, debug_img = tracker.predict(rgb_frame, predictions,
debug=args.debug_track)
# end_track = time.time() - start_track
# Action Recognition
if len(predictions) > 0 and args.task == 'action':
predictions = action_classifier.classify(predictions)
end_pipeline = time.time() - start_pose
# add user's desired text on render image
user_text.update({
'Frame': video.frame_cnt,
'Speed': '{:.1f}ms'.format(end_pipeline*1000),
})
# draw predicted results on bgr_img with frame info
render_image = drawer.render_frame(bgr_frame, predictions, **user_text)
if video.frame_cnt == 1 and args.save_folder:
# initiate writer for saving rendered video.
output_suffix = get_suffix(args, cfg)
output_path = video.get_output_file_path(
args.save_folder, suffix=output_suffix)
writer = video.get_writer(render_image, output_path, fps=30)
if args.debug_track and args.task != 'pose':
debug_output_path = output_path[:-4] + '_debug.avi'
debug_writer = video.get_writer(debug_img, debug_output_path)
print(f'[INFO] Saving video to : {output_path}')
# show frames
try:
if args.debug_track and args.task != 'pose':
debug_writer.write(debug_img)
utils.show(debug_img, window='debug_tracking')
if args.save_folder:
writer.write(render_image)
utils.show(render_image, window='webcam' if isinstance(source, int) else osp.basename(source))
except StopIteration:
break
if args.debug_track and args.task != 'pose':
debug_writer.release()
if args.save_folder and len(predictions) > 0:
writer.release()
video.stop()
def run_algo(data, nb_class, hparam, argv):
""" Use CONE algorithm on given options """
overall_timer = time()
outputs = {"confusions": {"train": np.zeros((argv.max_step, nb_class, nb_class), dtype=int),
"valid": np.zeros((argv.max_step, nb_class, nb_class), dtype=int),
"test": np.zeros((argv.max_step, nb_class, nb_class), dtype=int)},
"predictions": {"train": np.zeros((argv.max_step, data["train"]["labels"].shape[0], nb_class), dtype=np.float32),
"valid": np.zeros((argv.max_step, data["valid"]["labels"].shape[0], nb_class), dtype=np.float32),
"test": np.zeros((argv.max_step, data["test"]["labels"].shape[0], nb_class), dtype=np.float32)},
"t_values": np.full(argv.max_step, -1, dtype=np.float32)}
conf_mats = outputs["confusions"]
preds = outputs["predictions"]
best_fm = 0
next_t_val = (argv.tmin+argv.tmax)/2
max_fm = 1
step = 0
if argv.cone_with_state:
state = np.ones((argv.state_size, argv.state_size))
else:
saved_cones = np.zeros((argv.max_step+1, 6))
# add line y = 1 as "cone" to get early intersections points
saved_cones[0] = [0, -1, 0, 0, 1, 1]
poss_next_t = np.empty(0, dtype=np.float32)
poss_next_fm = np.empty(0, dtype=np.float32)
while max_fm >= best_fm and step < argv.max_step:
timer = time()
log.debug("Compute weights...")
outputs["t_values"][step] = next_t_val
class_w = compute_weights(outputs["t_values"][step], nb_class, argv.beta)
log.debug("Initialize classifier...")
classif = classifier.get_classifier(argv, hparam, class_w)
log.debug("Fit classifier...")
timer_train = time()
classif.fit(data["train"]["exemples"], data["train"]["labels"])
log.debug("\ttrain time: %f", time()-timer_train)
log.debug("Test classifier...")
timer_test = time()
for subset in ["train", "valid", "test"]:
out_iter = classifier.get_confusion(data, nb_class, subset, classif)
if nb_class == 2:
conf_mats[subset][step], preds[subset][step, :, 0] = out_iter
else:
conf_mats[subset][step], preds[subset][step] = out_iter
log.debug("\ttest time: %f", time()-timer_test)
log.debug("Select next cone...")
timer_cone = time()
if argv.cone_with_state:
timer_draw = time()
curr_fm = add_cone(state, conf_mats["train"][step], outputs["t_values"][step], argv)
log.debug("\t\tdrawing cone time: %f", time()-timer_draw)
timer_fm = time()
next_t_val, max_fm = get_best_fm_available(state, argv, t_vals=outputs["t_values"][:step+1])
log.debug("\t\tfind next cone time: %f", time()-timer_fm)
if argv.save_states:
state_to_png(state, argv, step)
else:
saved_cones[step+1] = get_slope(conf_mats["train"][step], outputs["t_values"][step],
"cone", beta=argv.beta)
curr_fm = saved_cones[step+1][0]
next_t_val, max_fm, poss_next_t, poss_next_fm = find_next_cone(saved_cones[:step+2],
outputs["t_values"][:step+1],
poss_next_t, poss_next_fm,
tmin=argv.tmin, tmax=argv.tmax)
log.debug("\tnext cone time: %f", time()-timer_cone)
if curr_fm > best_fm:
best_fm = curr_fm
log.debug("Step %d time: %f t: %.5f fm: %.5f next t: %.5f max fm: %.5f", step, time()-timer,
outputs["t_values"][step], curr_fm, next_t_val, max_fm)
step += 1
log.debug("TRAIN TIME: %f", time()-overall_timer)
return outputs
