y: test_set_y[index * batch_size:(index + 1) * batch_size],
},
)
# load weights
print("loading weights state")
f = open("weights.save", "rb")
loaded_objects = []
for i in range(5):
loaded_objects.append(pickle.load(f, encoding='bytes'))
f.close()
layer0.__setstate__(loaded_objects[0])
layer1.__setstate__(loaded_objects[1])
layer2.__setstate__(loaded_objects[2])
layer3.__setstate__(loaded_objects[3])
layer4.__setstate__(loaded_objects[4])
######################## build done ########################
inputfile = ""
fromCam = True
try:
opts, args = getopt.getopt(sys.argv[1:], "i:h:", ["ifile=", "help="])
except getopt.GetoptError:
print(
"invalid arguments. for input from camera, add -i <inputfile> for input from file"
)
sys.exit(2)
for opt, arg in opts:
if opt in ("-i", "--ifile"):
inputfile = arg
def start(inputfile):
global in_time, out_time, cooldown_in_time, cooldown_out_time, classify
global global_counter, winner_stride, cur_state, in_frame_num, actions_counter
global test_set_x, test_set_y, shared_test_set_y
rng = numpy.random.RandomState(23455)
# ####################### build start ########################
# create an empty shared variables to be filled later
data_x = numpy.zeros([1, 20 * 50 * 50])
data_y = numpy.zeros(20)
train_set = (data_x, data_y)
(test_set_x, test_set_y, shared_test_set_y) = \
shared_dataset(train_set)
print 'building ... '
batch_size = 1
# allocate symbolic variables for the data
index = T.lscalar()
x = T.matrix('x')
y = T.ivector('y')
# image size
layer0_w = 50
layer0_h = 50
layer1_w = (layer0_w - 4) / 2
layer1_h = (layer0_h - 4) / 2
layer2_w = (layer1_w - 2) / 2
layer2_h = (layer1_h - 2) / 2
layer3_w = (layer2_w - 2) / 2
layer3_h = (layer2_h - 2) / 2
# #####################
# BUILD ACTUAL MODEL #
# #####################
# image sizes
batchsize = batch_size
in_channels = 20
in_width = 50
in_height = 50
# filter sizes
flt_channels = 40
flt_time = 20
flt_width = 5
flt_height = 5
signals_shape = (batchsize, in_channels, in_height, in_width)
filters_shape = (flt_channels, in_channels, flt_height, flt_width)
layer0_input = x.reshape(signals_shape)
layer0 = LeNetConvPoolLayer(rng,
input=layer0_input,
image_shape=signals_shape,
filter_shape=filters_shape,
poolsize=(2, 2))
layer1 = LeNetConvPoolLayer(rng,
input=layer0.output,
image_shape=(batch_size, flt_channels,
layer1_w, layer1_h),
filter_shape=(60, flt_channels, 3, 3),
poolsize=(2, 2))
layer2 = LeNetConvPoolLayer(rng,
input=layer1.output,
image_shape=(batch_size, 60, layer2_w,
layer2_h),
filter_shape=(90, 60, 3, 3),
poolsize=(2, 2))
layer3_input = layer2.output.flatten(2)
layer3 = HiddenLayer(rng,
input=layer3_input,
n_in=90 * layer3_w * layer3_h,
n_out=500,
activation=T.tanh)
layer4 = LogisticRegression(input=layer3.output, n_in=500, n_out=8)
cost = layer4.negative_log_likelihood(y)
classify = theano.function(
[index],
outputs=layer4.get_output_labels(y),
givens={
x: test_set_x[index * batch_size:(index + 1) * batch_size],
y: test_set_y[index * batch_size:(index + 1) * batch_size]
})
# load weights
print 'loading weights state'
f = file('weights.save', 'rb')
loaded_objects = []
for i in range(5):
loaded_objects.append(cPickle.load(f))
f.close()
layer0.__setstate__(loaded_objects[0])
layer1.__setstate__(loaded_objects[1])
layer2.__setstate__(loaded_objects[2])
layer3.__setstate__(loaded_objects[3])
layer4.__setstate__(loaded_objects[4])
# ####################### build done ########################
fromCam = False
if fromCam:
print 'using camera input'
cap = cv2.VideoCapture(0)
else:
print 'using input file: ', inputfile
cap = cv2.VideoCapture(inputfile)
# my timing
frame_rate = 5
frame_interval_ms = 1000 / frame_rate
fourcc = cv2.VideoWriter_fourcc(*'XVID')
video_writer = cv2.VideoWriter('../out/live_out.avi', fourcc, frame_rate,
(640, 480))
frame_counter = 0
(ret, frame) = cap.read()
proFrame = process_single_frame(frame)
# init detectors
st_a_det = RepDetector(proFrame, detector_strides[0])
st_b_det = RepDetector(proFrame, detector_strides[1])
st_c_det = RepDetector(proFrame, detector_strides[2])
frame_wise_counts = []
while True:
in_frame_num += 1
if in_frame_num % 2 == 1:
continue
(ret, frame) = cap.read()
if ret == 0:
print 'unable to read frame'
break
proFrame = process_single_frame(frame)
# handle stride A....
if frame_counter % st_a_det.stride_number == 0:
st_a_det.count(proFrame)
# handle stride B
if frame_counter % st_b_det.stride_number == 0:
st_b_det.count(proFrame)
# handle stride C
if frame_counter % st_c_det.stride_number == 0:
st_c_det.count(proFrame)
# display result on video................
blue_color = (130, 0, 0)
green_color = (0, 130, 0)
red_color = (0, 0, 130)
orange_color = (0, 140, 0xFF)
out_time = in_frame_num / 60
if cur_state == state.IN_REP and (out_time - in_time < 4
or global_counter < 5):
draw_str(frame, (20, 120),
' new hypothesis (%d) ' % global_counter, orange_color,
1.5)
if cur_state == state.IN_REP and out_time - in_time >= 4 \
and global_counter >= 5:
draw_str(
frame, (20, 120), 'action %d: counting... %d' %
(actions_counter, global_counter), green_color, 2)
if cur_state == state.COOLDOWN and global_counter >= 5:
draw_str(
frame, (20, 120), 'action %d: done. final counting: %d' %
(actions_counter, global_counter), blue_color, 2)
# print "pls", global_counter
frame_wise_counts.append(global_counter)
# print 'action %d: done. final counting: %d' % (actions_counter, global_counter)
print "Dhruv", frame_wise_counts, global_counter
return frame_wise_counts
def prepare_network():
rng = numpy.random.RandomState(23455)
print('Preparing Theano model...')
mydatasets = load_initial_test_data()
test_set_x, test_set_y, shared_test_set_y, valid_ds = mydatasets
n_test_batches = test_set_x.get_value(borrow=True).shape[0]
# allocate symbolic variables for the data
index = T.lscalar()
x = T.matrix('x')
y = T.ivector('y')
# image size
layer0_w = 50
layer0_h = 50
layer1_w = (layer0_w - 4) // 2
layer1_h = (layer0_h - 4) // 2
layer2_w = (layer1_w - 2) // 2
layer2_h = (layer1_h - 2) // 2
layer3_w = (layer2_w - 2) // 2
layer3_h = (layer2_h - 2) // 2
######################
# BUILD NETWORK #
######################
# image sizes
batchsize = 1
in_channels = 20
in_width = 50
in_height = 50
#filter sizes
flt_channels = 40
flt_time = 20
flt_width = 5
flt_height = 5
signals_shape = (batchsize, in_channels, in_height, in_width)
filters_shape = (flt_channels, in_channels, flt_height, flt_width)
layer0_input = x.reshape(signals_shape)
layer0 = LeNetConvPoolLayer(rng,
input=layer0_input,
image_shape=signals_shape,
filter_shape=filters_shape,
poolsize=(2, 2))
layer1 = LeNetConvPoolLayer(rng,
input=layer0.output,
image_shape=(batchsize, flt_channels, layer1_w,
layer1_h),
filter_shape=(60, flt_channels, 3, 3),
poolsize=(2, 2))
layer2 = LeNetConvPoolLayer(rng,
input=layer1.output,
image_shape=(batchsize, 60, layer2_w,
layer2_h),
filter_shape=(90, 60, 3, 3),
poolsize=(2, 2))
layer3_input = layer2.output.flatten(2)
layer3 = HiddenLayer(rng,
input=layer3_input,
n_in=90 * layer3_w * layer3_h,
n_out=500,
activation=T.tanh)
layer4 = LogisticRegression(input=layer3.output, n_in=500, n_out=8)
cost = layer4.negative_log_likelihood(y)
classify = theano.function(
[index],
outputs=layer4.get_output_labels(y),
givens={
x: test_set_x[index * batchsize:(index + 1) * batchsize],
y: test_set_y[index * batchsize:(index + 1) * batchsize]
})
print('Loading network weights...')
weightFile = '../live_count/weights.save'
f = open(weightFile, 'rb')
loaded_objects = []
for i in range(5):
loaded_objects.append(pickle.load(f))
f.close()
layer0.__setstate__(loaded_objects[0])
layer1.__setstate__(loaded_objects[1])
layer2.__setstate__(loaded_objects[2])
layer3.__setstate__(loaded_objects[3])
layer4.__setstate__(loaded_objects[4])
return test_set_x, test_set_y, shared_test_set_y, valid_ds, classify, batchsize
givens={
x: test_set_x[index * batch_size: (index + 1) * batch_size],
y: test_set_y[index * batch_size: (index + 1) * batch_size]})
# load weights
print 'loading weights state'
f = file('weights.save', 'rb')
loaded_objects = []
for i in range(5):
loaded_objects.append(cPickle.load(f))
f.close()
layer0.__setstate__(loaded_objects[0])
layer1.__setstate__(loaded_objects[1])
layer2.__setstate__(loaded_objects[2])
layer3.__setstate__(loaded_objects[3])
layer4.__setstate__(loaded_objects[4])
######################## build done ###########################
countMap = numpy.zeros([num_of_vids,10])
for vidNum in range(1,num_of_vids+1):
# input video
cap = cv2.VideoCapture('../data/YTIO/YTIO_'+str(vidNum)+'.avi')
# output video
video_writer = cv2.VideoWriter('../out/YTIO_out'+str(vidNum)+'.avi', cv2.cv.CV_FOURCC(*'XVID'), frame_rate, (640, 480))
global_counter = 0
winner_stride = 0
