def testdata_preprocess2(imagedir, model, color=True, skip=True):
vid = videoto3d.Videoto3D(256, 256, 10)
test_images = os.listdir(imagedir)
test_data = []
labels = []
sum = 0.0
for file in test_images:
label = vid.get_test_classname(file)
#通过测试图片所在的文件夹的名称得到图片序列的标签
#labels.append(label)
image_folder_name = os.path.join(imagedir, file)
print(image_folder_name)
arr = read_image(image_folder_name)
arr = np.expand_dims(arr, axis=0)
#prediction=model.predict_classes(np.transpose(arr,axes=(0,2,3,4,1)))#prediction数值为0/1
prediction = model.predict_classes(
np.array(arr).transpose((0, 2, 3, 4, 1)))
print(prediction)
print(label)
if prediction == 1:
if label == 'norain':
sum += 1
else:
print('aaaa')
if label == 'rain':
sum += 1
test_data.append(list(arr))
print('sum={}'.format(sum))
acc = sum / len(test_images)
print('test_acc={}'.format(acc))
print('len(test_dataset)', len(test_images))
#return np.array(test_data).transpose((0,2,3,4,1)),labels
return acc, sum, len(test_images)
def process():
nclass = 8
depth = 15
skip = False
color = True
img_rows, img_cols, frames = 32, 32, depth
channel = 3 if color else 1
# 获取本机计算机名称
hostname = socket.gethostname()
# 获取本机ip
ip = socket.gethostbyname(hostname)
print(ip)
fname_npz = 'dataset_{}_{}_{}_{}.npz'.format(ip, nclass, depth, skip)
output = '/opt/ml/processing/processed_data/'
videos = '/opt/ml/processing/input_data/'
output_fname = output + fname_npz
vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
nb_classes = nclass
if os.path.exists(fname_npz):
loadeddata = np.load(fname_npz)
X, Y = loadeddata["X"], loadeddata["Y"]
else:
x, y = loaddata(videos, vid3d, nclass, output, color, skip)
X = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
Y = np_utils.to_categorical(y, nb_classes)
X = X.astype('float32')
np.savez(output_fname, X=X, Y=Y)
print('Saved dataset to ', output_fname)
print('X_shape:{}\nY_shape:{}'.format(X.shape, Y.shape))
def process():
nclass = 8
depth = 15
skip = False
color = True
img_rows, img_cols, frames = 32, 32, depth
channel = 3 if color else 1
fname_npz = 'dataset_{}_{}_{}.npz'.format(nclass, depth, skip)
output = 'default-output/'
videos = 'dataset/'
vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
nb_classes = nclass
if os.path.exists(fname_npz):
loadeddata = np.load(fname_npz)
X, Y = loadeddata["X"], loadeddata["Y"]
else:
x, y = loaddata(videos, vid3d, nclass, output, color, skip)
X = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
Y = np_utils.to_categorical(y, nb_classes)
X = X.astype('float32')
np.savez(fname_npz, X=X, Y=Y)
print('Saved dataset to dataset.npz.')
print('X_shape:{}\nY_shape:{}'.format(X.shape, Y.shape))
# def main():
# process()
# nclass = 8
# depth = 15
# skip = False
# color = True
# img_rows, img_cols, frames = 32, 32, depth
# channel = 3 if color else 1
# fname_npz = 'dataset_{}_{}_{}.npz'.format(
# nclass, depth, skip)
# output = 'default-output/'
# videos = 'dataset/'
# vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
# nb_classes = nclass
# if os.path.exists(fname_npz):
# loadeddata = np.load(fname_npz)
# X, Y = videoto3d.loadeddata["X"], loadeddata["Y"]
# else:
# x, y = videoto3d.loaddata(videos, vid3d, nclass,
# output, color, skip)
# X = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
# Y = np_utils.to_categorical(y, nb_classes)
# X = X.astype('float32')
# np.savez(fname_npz, X=X, Y=Y)
# print('Saved dataset to dataset.npz.')
# print('X_shape:{}\nY_shape:{}'.format(X.shape, Y.shape))
def testdata_preprocess2(imagedir, model, color=True, skip=True):
vid = videoto3d.Videoto3D(256, 256, 10)
test_images = os.listdir(imagedir)
test_data = []
labels = []
sum = 0.0
for file in test_images:
# 通过测试图片所在的文件夹的名称得到图片序列的标签
# labels.append(label)
image_folder_name = os.path.join(imagedir, file)
print(image_folder_name)
arr = read_image(image_folder_name)
arr = np.expand_dims(arr, axis=0)
# prediction=model.predict_classes(np.transpose(arr,axes=(0,2,3,4,1)))#prediction数值为0/1
prediction = model.predict(np.array(arr).transpose((0, 2, 3, 4, 1)))
print(prediction)
def main():
parser = argparse.ArgumentParser(
description='simple 3D convolution for action recognition')
parser.add_argument('--batch', type=int, default=128)
parser.add_argument('--epoch', type=int, default=100)
parser.add_argument('--videos', type=str, default='UCF101',
help='directory where videos are stored')
parser.add_argument('--nclass', type=int, default=101)
parser.add_argument('--output', type=str, required=True)
parser.add_argument('--color', type=bool, default=False)
parser.add_argument('--skip', type=bool, default=True)
parser.add_argument('--depth', type=int, default=10)
args = parser.parse_args()
img_rows, img_cols, frames = 32, 32, args.depth
channel = 3 if args.color else 1
fname_npz = 'dataset_{}_{}_{}.npz'.format(
args.nclass, args.depth, args.skip)
vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
nb_classes = args.nclass
if os.path.exists(fname_npz):
loadeddata = np.load(fname_npz)
X, Y = loadeddata["X"], loadeddata["Y"]
else:
x, y = loaddata(args.videos, vid3d, args.nclass,
args.output, args.color, args.skip)
X = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
Y = np_utils.to_categorical(y, nb_classes)
X = X.astype('float32')
np.savez(fname_npz, X=X, Y=Y)
print('Saved dataset to dataset.npz.')
print('X_shape:{}\nY_shape:{}'.format(X.shape, Y.shape))
X_train, X_test, Y_train, Y_test = train_test_split(
X, Y, test_size=0.2, random_state=43)
print('Test loss:', loss)
print('Test accuracy:', acc)
plot_history(history, args.output)
save_history(history, args.output)
def data_preprocess(args):
assert type(args) == argparse.Namespace, 'args type error'
vid3d = videoto3d.Videoto3D(args.size[0],args.size[1],args.depth)
nb_classes = args.nclass
channel = 3 if args.color else 1
fname_npz = 'dataset_{}_{}_{}.npz'.format(#npz类型为numpy数组保存的文件名，
args.nclass, args.depth, args.skip)
if os.path.exists(fname_npz):
loadeddata = np.load(fname_npz)
train_data, train_label = loadeddata["train_data"], loadeddata["train_label"]
else:
train_data,labels = loaddata_image(args.videos, vid3d, args.nclass,
args.output, args.color, args.skip)
train_label = np_utils.to_categorical(labels, nb_classes)
train_data = train_data.astype('float32')
np.savez(fname_npz, train_data=train_data, train_label=train_label)
print('Saved dataset to dataset.npz.')
print('data_shape:{}\nlabel_shape:{}'.format(train_data.shape, train_label.shape))
return train_data,train_label,nb_classes
def testdata_preprocess2(imagedir, model, color=True, skip=True):
i = 0
vid = videoto3d.Videoto3D(32, 32, 10)
test_images = os.listdir(imagedir)
test_data = []
labels = []
sum = 0.0
for file in test_images:
i = i + 1
if i == 2:
break
label = vid.get_test_classname(file)
#通过测试图片所在的文件夹的名称得到图片序列的标签
#labels.append(label)
image_folder_name = os.path.join(imagedir, file)
print(image_folder_name)
arr = read_image(image_folder_name)
arr = np.expand_dims(arr, axis=0)
prediction = model.predict_classes(
np.transpose(arr, axes=(0, 2, 3, 4, 1))) #prediction数值为0/1
def main():
parser = argparse.ArgumentParser(
description='simple 3D convolution for action recognition')
parser.add_argument('--data_dir', type=str, default="./data/")
parser.add_argument('--batch', type=int, default=16)
parser.add_argument('--epoch', type=int, default=10000)
parser.add_argument('--color', type=bool, default=True)
parser.add_argument('--skip', type=bool, default=True)
parser.add_argument('--depth', type=int, default=32)
parser.add_argument('--calculateEvaluationCCC',
type=str,
default="./data/calculateEvaluationCCC.py")
parser.add_argument('--validationCSV',
type=str,
default="./data/omg_ValidationVideos.csv")
parser.add_argument('--testCSV',
type=str,
default="./data/omg_TestVideos.csv")
parser.add_argument('--trainCSV',
type=str,
default="./data/omg_TrainVideos.csv")
args = parser.parse_args()
timestamp = str(int(time.time()))
args.out_dir = os.path.abspath(os.path.join("runs", timestamp))
all_x = []
all_y = []
nb_classes = 2
for mode in ["Train", "Validation", "Test"]:
img_rows, img_cols, frames = 32, 32, args.depth
channel = 3 if args.color else 1
fname_npz = os.path.join(args.data_dir,
'dataset_{}_{}_{}_{}.npz').format(
mode, nb_classes, args.depth, args.skip)
vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
print(fname_npz)
if os.path.exists(fname_npz):
loadeddata = np.load(fname_npz)
X, Y = loadeddata["X"], loadeddata["Y"]
print("Dataset found already for mode ", mode)
else:
x, y = utils.loaddata("{}_videos".format(mode), vid3d, args, mode,
args.color, args.skip)
X = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
X = X.astype('float32')
Y = np.array(y)
np.savez(fname_npz, X=X, Y=Y)
print('Saved dataset to dataset.npz.')
all_x.append(X)
all_y.append(Y)
X_train, X_test, _ = all_x
Y_train, Y_test, _ = all_y
print('Train : X_shape:{}\nY_shape:{}'.format(X_train.shape,
Y_train.shape))
print('Validation : X_shape:{}\nY_shape:{}'.format(X_test.shape,
Y_test.shape))
# Define model
model = Sequential()
model.add(
Conv3D(32,
kernel_size=(5, 5, 5),
input_shape=(X.shape[1:]),
padding='same'))
# model.add(Activation('relu'))
# model.add(Conv3D(32, kernel_size=(3, 3, 3), padding='same'))
model.add(Activation('softmax'))
model.add(MaxPooling3D(pool_size=(4, 4, 4), padding='same'))
model.add(Dropout(0.2))
#
model.add(Conv3D(32, kernel_size=(5, 5, 5), padding='same'))
# model.add(Activation('relu'))
# model.add(Conv3D(32, kernel_size=(3, 3, 3), padding='same'))
model.add(Activation('softmax'))
model.add(MaxPooling3D(pool_size=(3, 3, 3), padding='same'))
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(128, activation='sigmoid'))
model.add(Dropout(0.2))
model.add(Dense(2, activation='linear'))
model.compile(loss='mse', optimizer=Adam(lr=0.001), metrics=['mse'])
model.summary()
# for i, j in enumerate(model.layers):
# print(i,j)
# sys.exit()
if not os.path.isdir(args.out_dir):
os.makedirs(args.out_dir)
model_json = model.to_json()
with open(os.path.join(args.out_dir, 'model.json'), 'w') as json_file:
json_file.write(model_json)
filepath = os.path.join(
args.out_dir, "weights-improvement-{epoch:02d}-{val_loss:.2f}.hdf5")
checkpoint = ModelCheckpoint(filepath)
predictions = utils.prediction_history(X_test, model, args)
callbacks_list = [checkpoint, predictions]
history = model.fit(X_train,
Y_train,
validation_data=(X_test, Y_test),
batch_size=args.batch,
epochs=args.epoch,
verbose=1,
shuffle=True,
callbacks=callbacks_list)
def main():
parser = argparse.ArgumentParser(
description='simple 3D convolution for action recognition')
parser.add_argument('--batch', type=int, default=128)
parser.add_argument('--epoch', type=int, default=50)
parser.add_argument('--videos', type=str, default='UCF101',
help='directory where videos are stored')
parser.add_argument('--nclass', type=int, default=101)
parser.add_argument('--output', type=str, required=True)
parser.add_argument('--color', type=bool, default=True)
parser.add_argument('--skip', type=bool, default=False)
parser.add_argument('--depth', type=int, default=60)
args = parser.parse_args()
img_rows, img_cols, frames = 32, 32, args.depth
channel = 3 if args.color else 1
fname_npz = 'dataset_{}_{}_{}.npz'.format(
args.nclass, args.depth, args.skip)
vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
nb_classes = args.nclass
if os.path.exists(fname_npz):
loadeddata = np.load(fname_npz)
print("OS Path exists.\n")
X, Y = loadeddata["X"], loadeddata["Y"]
else:
x, y = loaddata(args.videos, vid3d, args.nclass,
args.output, args.color, args.skip)
print("Inside Else")
X = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
Y = np_utils.to_categorical(y, nb_classes)
X = X.astype('float32')
np.savez(fname_npz, X=X, Y=Y)
print('Saved dataset to dataset.npz.')
print('X_shape:{}\nY_shape:{}'.format(X.shape, Y.shape))
# Define model
model = Sequential()
model.add(Conv3D(32, kernel_size=(3, 3, 3), input_shape=(
X.shape[1:]), border_mode='same'))
# model.add(Activation('relu'))
# model.add(Conv3D(32, kernel_size=(3, 3, 3), border_mode='same'))
# model.add(Activation('softmax'))
# model.add(MaxPooling3D(pool_size=(3, 3, 3), border_mode='same'))
# model.add(Dropout(0.25))
model.add(Activation('relu'))
model.add(Conv3D(32, kernel_size=(3, 3, 3), border_mode='same'))
model.add(Activation('softmax'))
model.add(MaxPooling3D(pool_size=(3, 3, 3), border_mode='same'))
model.add(Dropout(0.25))
model.add(Conv3D(64, kernel_size=(3, 3, 3), border_mode='same'))
model.add(Activation('relu'))
model.add(Conv3D(64, kernel_size=(3, 3, 3), border_mode='same'))
model.add(Activation('softmax'))
model.add(MaxPooling3D(pool_size=(3, 3, 3), border_mode='same'))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(512, activation='sigmoid'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes, activation='softmax'))
model.compile(loss=categorical_crossentropy,
optimizer=Adam(), metrics=['accuracy'])
model.summary()
# plot_model(model, show_shapes=True,
# to_file=os.path.join(args.output, 'model.png'))
X_train, X_test, Y_train, Y_test = train_test_split(
X, Y, test_size=0.2, random_state=43)
####################
# 1
filepath="d_3dcnnmodel-{epoch:02d}-{val_acc:.2f}.hd5"
checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max')
callbacks_list = [checkpoint]
# 2
config = tf.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.3
set_session(tf.Session(config=config))
###############
# Train model
history = model.fit(X_train, Y_train, validation_data=(X_test, Y_test), batch_size=args.batch,
epochs=args.epoch, verbose=1, shuffle=True, callbacks=callbacks_list)
model.evaluate(X_test, Y_test, verbose=0)
model_json = model.to_json()
if not os.path.isdir(args.output):
os.makedirs(args.output)
with open(os.path.join(args.output, 'sign-15-images.json'), 'w') as json_file:
json_file.write(model_json)
model.save_weights(os.path.join(args.output, 'sign-15-images.hd5'))
loss, acc = model.evaluate(X_test, Y_test, verbose=0)
print('Test loss:', loss)
print('Test accuracy:', acc)
plot_history(history, args.output)
save_history(history, args.output)
def main():
parser = argparse.ArgumentParser(
description='simple 3D convolution for action recognition')
parser.add_argument('--batch', type=int, default=128)
parser.add_argument('--epoch', type=int, default=100)
parser.add_argument('--videos', type=str, default='UCF101',
help='directory where videos are stored')
parser.add_argument('--nclass', type=int, default=101)
parser.add_argument('--output', type=str, required=True)
parser.add_argument('--color', type=bool, default=False)
parser.add_argument('--skip', type=bool, default=True)
parser.add_argument('--depth', type=int, default=10)
parser.add_argument('--model_dir', type=str)
parser.add_argument('--sm-model-dir', type=str, default=os.environ.get('SM_MODEL_DIR'))
parser.add_argument('--train', type=str, default=os.environ.get('SM_CHANNEL_TRAINING'))
parser.add_argument('--hosts', type=list, default=json.loads(os.environ.get('SM_HOSTS')))
parser.add_argument('--current-host', type=str, default=os.environ.get('SM_CURRENT_HOST'))
args = parser.parse_args()
img_rows, img_cols, frames = 32, 32, args.depth
channel = 3 if args.color else 1
fname_npz = 'dataset_{}_{}_{}.npz'.format(
args.nclass, args.depth, args.skip)
vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
nb_classes = args.nclass
if os.path.exists(fname_npz):
loadeddata = np.load(fname_npz)
X, Y = loadeddata["X"], loadeddata["Y"]
else:
x, y = loaddata(args.videos, vid3d, args.nclass,
args.output, args.color, args.skip)
X = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
Y = np_utils.to_categorical(y, nb_classes)
X = X.astype('float32')
np.savez(fname_npz, X=X, Y=Y)
print('Saved dataset to dataset.npz.')
print('X_shape:{}\nY_shape:{}'.format(X.shape, Y.shape))
# Define model
model = Sequential()
model.add(Conv3D(32, kernel_size=(3, 3, 3), input_shape=(
X.shape[1:]), padding='same'))
model.add(Activation('relu'))
model.add(Conv3D(32, kernel_size=(3, 3, 3), padding='same'))
model.add(Activation('softmax'))
model.add(MaxPooling3D(pool_size=(3, 3, 3), padding='same'))
model.add(Dropout(0.25))
model.add(Conv3D(64, kernel_size=(3, 3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv3D(64, kernel_size=(3, 3, 3), padding='same'))
model.add(Activation('softmax'))
model.add(MaxPooling3D(pool_size=(3, 3, 3), padding='same'))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(512, activation='sigmoid'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes, activation='softmax'))
model.compile(loss=categorical_crossentropy,
optimizer=Adam(), metrics=['accuracy'])
model.summary()
# plot_model(model, show_shapes=True,
# to_file=os.path.join(args.output, 'model.png'))
X_train, X_test, Y_train, Y_test = train_test_split(
X, Y, test_size=0.2, random_state=43)
history = model.fit(X_train, Y_train, validation_data=(X_test, Y_test), batch_size=args.batch,
epochs=args.epoch, verbose=1, shuffle=True)
model.evaluate(X_test, Y_test, verbose=0)
model_json = model.to_json()
if not os.path.isdir(args.output):
os.makedirs(args.output)
with open(os.path.join(args.output, 'ucf101_3dcnnmodel.json'), 'w') as json_file:
json_file.write(model_json)
model.save_weights(os.path.join(args.output, 'ucf101_3dcnnmodel.hd5'))
loss, acc = model.evaluate(X_test, Y_test, verbose=0)
print('Test loss:', loss)
print('Test accuracy:', acc)
plot_history(history, args.output)
save_history(history, args.output)
def main():
parser = argparse.ArgumentParser(
description='simple 3D convolution for action recognition')
parser.add_argument('--batch', type=int, default=128)
parser.add_argument('--epoch', type=int, default=50)
parser.add_argument('--videos',
type=str,
default='3dCNN/UCF101/',
help='directory where videos are stored')
parser.add_argument('--nclass', type=int, default=101)
#parser.add_argument('--nsplit', type=int, default=1) # Add
parser.add_argument('--output', type=str, default='finalmy3dcnnresult/')
parser.add_argument('--color', type=bool, default=True)
parser.add_argument('--skip', type=bool, default=False)
parser.add_argument('--depth', type=int, default=15)
args = parser.parse_args()
#img_rows, img_cols, frames = 32, 32, args.depth - Defaultvalue
# The origin size of UCF101 is 320x240
img_rows, img_cols, frames = 24, 32, args.depth
channel = 3 if args.color else 1
# Train
fname_train_npz = 'train_dataset_{}_{}_{}.npz'.format(
args.nclass, args.depth, args.skip)
vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
nb_classes = args.nclass
if os.path.exists(fname_train_npz):
train_loadeddata = np.load(fname_train_npz)
trainX, trainY = train_loadeddata["X"], train_loadeddata["Y"]
else:
x, y = loadTraindata(args.videos, vid3d, args.nclass, args.output,
args.color,
args.skip) # Add args.nsplit as argument
trainX = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
trainY = np_utils.to_categorical(y, nb_classes)
trainX = trainX.astype('float32')
np.savez(fname_train_npz, X=trainX, Y=trainY)
print('Saved train dataset to train_dataset.npz.')
print('trainX_shape:{}\ntrainY_shape:{}'.format(trainX.shape,
trainY.shape))
# Test
fname_test_npz = 'test_dataset_{}_{}_{}.npz'.format(
args.nclass, args.depth, args.skip)
#vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
#nb_classes = args.nclass
if os.path.exists(fname_test_npz):
test_loadeddata = np.load(fname_test_npz)
testX, testY = test_loadeddata["X"], test_loadeddata["Y"]
else:
x, y = loadTestdata(args.videos, vid3d, args.nclass, args.output,
args.color,
args.skip) # Add args.nsplit as argument
testX = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
testY = np_utils.to_categorical(y, nb_classes)
testX = testX.astype('float32')
np.savez(fname_test_npz, X=testX, Y=testY)
print('Saved test dataset to test_dataset.npz.')
print('testX_shape:{}\ntestY_shape:{}'.format(testX.shape, testY.shape))
# Define model
model = Sequential()
# Default initialization in Keras is glorot_uniform (same as Xavier)
model.add(
Conv3D(32,
kernel_size=(3, 3, 3),
input_shape=(trainX.shape[1:]),
border_mode='same'))
model.add(Activation('relu'))
model.add(BatchNormalization())
model.add(Conv3D(32, kernel_size=(3, 3, 3), border_mode='same'))
#model.add(Activation('softmax'))
model.add(Activation('relu'))
model.add(BatchNormalization())
model.add(MaxPooling3D(pool_size=(3, 3, 3), border_mode='same'))
model.add(Dropout(0.25))
model.add(Conv3D(64, kernel_size=(3, 3, 3), border_mode='same'))
model.add(Activation('relu'))
model.add(BatchNormalization())
model.add(Conv3D(64, kernel_size=(3, 3, 3), border_mode='same'))
#model.add(Activation('softmax'))
model.add(Activation('relu'))
model.add(BatchNormalization())
model.add(MaxPooling3D(pool_size=(3, 3, 3), border_mode='same'))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(512, activation='sigmoid'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes, activation='softmax'))
model.compile(loss=categorical_crossentropy,
optimizer='adam',
metrics=['accuracy'])
model.summary()
earlystop = EarlyStopping(monitor='val_acc',
min_delta=0.001,
patience=5,
verbose=1,
mode='auto')
callbacks_list = [earlystop]
#plot_model(model, show_shapes=True,
# to_file=os.path.join(args.output, 'model.png'))
#Xtrain, Xvalid, Ytrain, Yvalid = train_test_split(trainX, trainY, test_size=0.1, random_state=43)
# Just for testing
#Xtrain, Xvalid, Ytrain, Yvalid = Xtrain[:2560], Xvalid[:256], Ytrain[:2560], Yvalid[:256]
#history = model.fit(Xtrain, Ytrain, validation_data=(Xvalid, Yvalid), batch_size=args.batch,
# epochs=args.epoch, callbacks=callbacks_list, verbose=1, shuffle=True)
history = model.fit(trainX,
trainY,
batch_size=args.batch,
epochs=args.epoch,
callbacks=callbacks_list,
verbose=1,
shuffle=True)
#model.evaluate(testX, testY, verbose=0)
model_json = model.to_json()
if not os.path.isdir(args.output):
os.makedirs(args.output)
with open(os.path.join(args.output, 'ucf101_3dcnnmodel.json'),
'w') as json_file:
json_file.write(model_json)
model.save_weights(os.path.join(args.output, 'ucf101_3dcnnmodel.hd5'))
loss, acc = model.evaluate(testX, testY, verbose=0)
print('Test loss:', loss)
print('Test accuracy:', acc)
plot_history(history, args.output)
save_history(history, args.output)
predY = model.predict(testX)
# To get the confusion matrix
testYle = np.argmax(testY, axis=1)
predYle = np.argmax(predY, axis=1)
print 'testY: {0}'.format(np.argmax(testY, axis=1))
print 'predY: {0}'.format(np.argmax(predY, axis=1))
cm = confusion_matrix(testYle, predYle)
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
plot_confusion_matrix(cm=cm)
def main():
parser = argparse.ArgumentParser(
description='simple 3D convolution for action recognition')
parser.add_argument('--batch', type=int, default=128)
parser.add_argument('--epoch', type=int, default=100)
parser.add_argument('--videos',
type=str,
default='UCF101',
help='directory where videos are stored')
parser.add_argument('--nclass', type=int, default=101)
parser.add_argument('--output', type=str, required=True)
parser.add_argument('--color', type=bool, default=False)
parser.add_argument('--skip', type=bool, default=True)
parser.add_argument('--depth', type=int, default=10)
parser.add_argument('--nmodel', type=int, default=3)
args = parser.parse_args()
if not os.path.isdir(args.output):
os.makedirs(args.output)
img_rows, img_cols, frames = 32, 32, args.depth
channel = 3 if args.color else 1
vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
nb_classes = args.nclass
fname_npz = 'dataset_{}_{}_{}.npz'.format(args.nclass, args.depth,
args.skip)
if os.path.exists(fname_npz):
loadeddata = np.load(fname_npz)
X, Y = loadeddata["X"], loadeddata["Y"]
else:
x, y = loaddata(args.videos, vid3d, args.nclass, args.output,
args.color, args.skip)
X = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
Y = np_utils.to_categorical(y, nb_classes)
X = X.astype('float32')
np.savez(fname_npz, X=X, Y=Y)
print('Saved dataset to dataset.npz.')
print('X_shape:{}\nY_shape:{}'.format(X.shape, Y.shape))
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
test_size=0.2,
random_state=4)
# Define model
models = []
for i in range(args.nmodel):
print('model{}:'.format(i))
models.append(create_3dcnn(X.shape[1:], nb_classes))
models[-1].compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
history = models[-1].fit(X_train,
Y_train,
validation_data=(X_test, Y_test),
batch_size=args.batch,
nb_epoch=args.epoch,
verbose=1,
shuffle=True)
plot_history(history, args.output, i)
save_history(history, args.output, i)
model_inputs = [Input(shape=X.shape[1:]) for _ in range(args.nmodel)]
model_outputs = [models[i](model_inputs[i]) for i in range(args.nmodel)]
model_outputs = average(inputs=model_outputs)
model = Model(inputs=model_inputs, outputs=model_outputs)
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
#model.summary()
plot_model(model,
show_shapes=True,
to_file=os.path.join(args.output, 'model.png'))
model_json = model.to_json()
with open(os.path.join(args.output, 'ucf101_3dcnnmodel.json'),
'w') as json_file:
json_file.write(model_json)
model.save_weights(os.path.join(args.output, 'ucf101_3dcnnmodel.hd5'))
loss, acc = model.evaluate([X_test] * args.nmodel, Y_test, verbose=0)
with open(os.path.join(args.output, 'result.txt'), 'w') as f:
f.write('Test loss: {}\nTest accuracy:{}'.format(loss, acc))
print('merged model:')
print('Test loss:', loss)
print('Test accuracy:', acc)
def main():
parser = argparse.ArgumentParser(
description='simple 3D convolution for action recognition')
parser.add_argument('--batch', type=int, default=128)
parser.add_argument('--epoch', type=int, default=100)
parser.add_argument('--videos',
type=str,
default='UCF101',
help='directory where videos are stored')
parser.add_argument('--nclass', type=int, default=101)
parser.add_argument('--output', type=str, required=True)
parser.add_argument('--color', type=bool, default=False)
parser.add_argument('--skip', type=bool, default=True)
parser.add_argument('--depth', type=int, default=10)
args = parser.parse_args()
img_rows, img_cols = 224, 224
frames = args.depth
nb_classes = args.nclass
nb_batch = args.batch
channel = 3 if args.color else 1
fname_npz = 'dataset_{}_{}_{}.npz'.format(args.nclass, args.depth,
args.skip)
vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
if os.path.exists(fname_npz):
loadeddata = np.load(fname_npz)
X, Y = loadeddata["X"], loadeddata["Y"]
else:
x, y = loaddata(args.videos, vid3d, nb_classes, args.output,
args.color, args.skip)
print(x.shape)
print(x.size)
X = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
Y = np_utils.to_categorical(y, nb_classes)
X = X.astype('float32')
np.savez(fname_npz, X=X, Y=Y)
print('Saved dataset to dataset.npz.')
print('X_shape:{}\nY_shape:{}'.format(X.shape, Y.shape))
# Define model
input_x = Input(shape=(img_rows, img_cols, frames, channel))
initial_conv = Conv3D(16, kernel_size=(3, 3, 3), padding='same')(input_x)
initial_conv = LeakyReLU(alpha=.001)(initial_conv)
initial_conv = Conv3D(32, kernel_size=(3, 3, 3),
padding='same')(initial_conv)
initial_conv = LeakyReLU(alpha=.001)(initial_conv)
###########################
# PARALLEL 1
conv1 = Conv3D(16, kernel_size=(1, 1, 1), padding='same')(initial_conv)
conv1 = LeakyReLU(alpha=.001)(conv1)
conv1 = MaxPooling3D(pool_size=(2, 2, 2), padding='same')(conv1)
conv1 = Conv3D(16, kernel_size=(3, 3, 3), padding='same')(conv1)
conv1 = LeakyReLU(alpha=.001)(conv1)
conv1 = MaxPooling3D(pool_size=(2, 2, 2), padding='same')(conv1)
conv1 = Conv3D(1, kernel_size=(1, 1, 1), padding='same')(conv1)
conv1 = LeakyReLU(alpha=.001)(conv1)
##############################
#Parallel 2
conv2 = Conv3D(8, kernel_size=(1, 1, 1), padding='same')(initial_conv)
conv2 = LeakyReLU(alpha=.001)(conv2)
conv2 = MaxPooling3D(pool_size=(2, 2, 2), padding='same')(conv2)
conv2 = Conv3D(8, kernel_size=(3, 3, 3), padding='same')(conv2)
conv2 = LeakyReLU(alpha=.001)(conv2)
conv2 = MaxPooling3D(pool_size=(2, 2, 2), padding='same')(conv2)
conv2 = Conv3D(1, kernel_size=(1, 1, 1), padding='same')(conv2)
conv2 = LeakyReLU(alpha=.001)(conv2)
##############################
#Parallel 3
conv3 = Conv3D(4, kernel_size=(1, 1, 1), padding='same')(initial_conv)
conv3 = LeakyReLU(alpha=.001)(conv3)
conv3 = MaxPooling3D(pool_size=(2, 2, 2), padding='same')(conv3)
conv3 = Conv3D(4, kernel_size=(3, 3, 3), padding='same')(conv3)
conv3 = LeakyReLU(alpha=.001)(conv3)
conv3 = MaxPooling3D(pool_size=(2, 2, 2), padding='same')(conv3)
conv3 = Conv3D(1, kernel_size=(1, 1, 1), padding='same')(conv3)
conv3 = LeakyReLU(alpha=.001)(conv3)
###################################
added = keras.layers.Add()([conv1, conv2, conv3])
added = MaxPooling3D(pool_size=(2, 2, 2), padding='same')(added)
added = Flatten()(added)
dense_1 = Dense(784)(added)
dense_2 = Dense(nb_classes)(dense_1)
print(dense_2.shape)
model = Model(input_x, dense_2)
model.compile(loss=categorical_crossentropy,
optimizer=Adam(),
metrics=['accuracy'])
model.summary()
# plot_model(model, show_shapes=True,
# to_file=os.path.join(args.output, 'model.png'))
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
test_size=0.2,
random_state=43)
print(X_train.shape)
print(X_test.shape)
####################
# MODEL CHECK POINTS
filepath = "saved_models/dk_3dcnnmodel-{epoch:02d}-{val_acc:.2f}.hd5"
checkpoint = ModelCheckpoint(filepath,
monitor='val_acc',
verbose=1,
save_best_only=True,
mode='max')
callbacks_list = [checkpoint]
# GPU CONFIGURATION
config = tf.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.3
set_session(tf.Session(config=config))
print(X_train.shape)
print(Y_train.shape)
# history = model.fit(X_train, Y_train, validation_data=(X_test, Y_test), batch_size=args.batch,
# epochs=args.epoch, verbose=1, shuffle=True, callbacks=callbacks_list)
history = model.fit_generator(myGenerator(X_train, X_test, Y_train, Y_test,
nb_classes, nb_batch),
samples_per_epoch=X_train.shape[0],
epochs=args.epoch,
verbose=1,
callbacks=callbacks_list,
shuffle=True)
model.evaluate(X_test, Y_test, verbose=0)
model_json = model.to_json()
if not os.path.isdir(args.output):
os.makedirs(args.output)
with open(os.path.join(args.output, 'ucf101_3dcnnmodel.json'),
'w') as json_file:
json_file.write(model_json)
model.save_weights(os.path.join(args.output, 'ucf101_3dcnnmodel-gpu.hd5'))
loss, acc = model.evaluate(X_test, Y_test, verbose=0)
print('Test loss:', loss)
print('Test accuracy:', acc)
plot_history(history, args.output)
save_history(history, args.output)
def main():
'''define the argument when execute'''
parser = argparse.ArgumentParser(
description='simple 3D convolution for action recognition')
#batch: use how many samples to train at a time
parser.add_argument('--batch', type=int, default=128)
#epoch: how many times tarin forward and backward
parser.add_argument('--epoch', type=int, default=20)
parser.add_argument('--videos',
type=str,
default='VIDEO_RGB',
help='directory where videos are stored')
parser.add_argument('--nclass', type=int, default=12)
parser.add_argument('--output', type=str, default='3dcnn-result')
parser.add_argument('--color', type=bool, default=False)
parser.add_argument('--skip', type=bool, default=True)
parser.add_argument('--depth', type=int, default=20)
args = parser.parse_args()
'''initilize training sample and transform dataset'''
img_rows, img_cols, frames = 32, 32, args.depth
#rgb channel or else
channel = 3 if args.color else 1
fname_npz = 'dataset_{}_{}_{}.npz'.format(args.nclass, args.depth,
args.skip)
'''load data
X:?
Y:
'''
vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
nb_classes = args.nclass
if os.path.exists(fname_npz):
#data alr exist
loadeddata = np.load(fname_npz)
X, Y = loadeddata["X"], loadeddata["Y"]
else:
#use method loaddata(): x, y?
x, y = loaddata(args.videos, vid3d, args.nclass, args.output,
args.color, args.skip)
#?
X = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
#?
Y = np_utils.to_categorical(y, nb_classes)
X = X.astype('float32')
np.savez(fname_npz, X=X, Y=Y)
print('Saved dataset to dataset.npz.')
print('X_shape:{}\nY_shape:{}'.format(X.shape, Y.shape))
'''Define model'''
model = Sequential()
model.add(
Conv3D(32,
kernel_size=(3, 3, 3),
input_shape=(X.shape[1:]),
border_mode='same'))
model.add(Activation('relu'))
model.add(Conv3D(32, kernel_size=(3, 3, 3), border_mode='same'))
model.add(Activation('softmax'))
model.add(MaxPooling3D(pool_size=(3, 3, 3), border_mode='same'))
model.add(Dropout(0.25))
model.add(Conv3D(64, kernel_size=(3, 3, 3), border_mode='same'))
model.add(Activation('relu'))
model.add(Conv3D(64, kernel_size=(3, 3, 3), border_mode='same'))
model.add(Activation('softmax'))
model.add(MaxPooling3D(pool_size=(3, 3, 3), border_mode='same'))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(512, activation='sigmoid'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes, activation='softmax'))
model.compile(loss=categorical_crossentropy,
optimizer=Adam(),
metrics=['accuracy'])
model.summary()
plot_model(model,
show_shapes=True,
to_file=os.path.join(args.output, 'model.png'))
'''split dataset into train and test'''
#random_state: random seed, make sure each time the splitted result is the same
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
test_size=0.2,
random_state=43)
####################
# # 1
# filepath="d_3dcnnmodel-{epoch:02d}-{val_acc:.2f}.hd5"
# checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max')
# callbacks_list = [checkpoint]
# # 2
# config = tf.ConfigProto()
# config.gpu_options.per_process_gpu_memory_fraction = 0.3
# set_session(tf.Session(config=config))
###############
'''train the model for defined iterations'''
history = model.fit(X_train,
Y_train,
validation_data=(X_test, Y_test),
batch_size=args.batch,
epochs=args.epoch,
verbose=1,
shuffle=True,
callbacks=callbacks_list)
'''save history file .hd5'''
model.evaluate(X_test, Y_test, verbose=0)
model_json = model.to_json()
if not os.path.isdir(args.output):
os.makedirs(args.output)
with open(os.path.join(args.output, 'ucf101_3dcnnmodel.json'),
'w') as json_file:
json_file.write(model_json)
model.save_weights(os.path.join(args.output, 'ucf101_3dcnnmodel-gpu.hd5'))
'''deal with the evaluation stuff'''
loss, acc = model.evaluate(X_test, Y_test, verbose=0)
print('Test loss:', loss)
print('Test accuracy:', acc)
plot_history(history, args.output)
save_history(history, args.output)
def main():
parser = argparse.ArgumentParser(
description='simple 3D convolution for action recognition')
parser.add_argument('--batch', type=int, default=128)
parser.add_argument('--epoch', type=int, default=25)
parser.add_argument('--videos',
type=str,
default='3dCNN/UCF101/',
help='directory where videos are stored')
parser.add_argument('--nclass', type=int, default=101)
#parser.add_argument('--nsplit', type=int, default=1) # Add
parser.add_argument('--output', type=str, default='ens_my3dcnnresult/')
parser.add_argument('--color', type=bool, default=True)
parser.add_argument('--skip', type=bool, default=False)
parser.add_argument('--depth', type=int, default=15)
parser.add_argument('--nmodel', type=int, default=5)
args = parser.parse_args()
if not os.path.isdir(args.output):
os.makedirs(args.output)
img_rows, img_cols, frames = 24, 32, args.depth
channel = 3 if args.color else 1
# Train
fname_train_npz = 'train_dataset_{}_{}_{}.npz'.format(
args.nclass, args.depth, args.skip)
vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
nb_classes = args.nclass
if os.path.exists(fname_train_npz):
train_loadeddata = np.load(fname_train_npz)
trainX, trainY = train_loadeddata["X"], train_loadeddata["Y"]
else:
x, y = loadTraindata(args.videos, vid3d, args.nclass, args.output,
args.color,
args.skip) # Add args.nsplit as argument
trainX = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
trainY = np_utils.to_categorical(y, nb_classes)
trainX = trainX.astype('float32')
np.savez(fname_train_npz, X=trainX, Y=trainY)
print('Saved train dataset to train_dataset.npz.')
print('trainX_shape:{}\ntrainY_shape:{}'.format(trainX.shape,
trainY.shape))
# Test
fname_test_npz = 'test_dataset_{}_{}_{}.npz'.format(
args.nclass, args.depth, args.skip)
#vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
#nb_classes = args.nclass
if os.path.exists(fname_test_npz):
test_loadeddata = np.load(fname_test_npz)
testX, testY = test_loadeddata["X"], test_loadeddata["Y"]
else:
x, y = loadTestdata(args.videos, vid3d, args.nclass, args.output,
args.color,
args.skip) # Add args.nsplit as argument
testX = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
testY = np_utils.to_categorical(y, nb_classes)
testX = testX.astype('float32')
np.savez(fname_test_npz, X=testX, Y=testY)
print('Saved test dataset to test_dataset.npz.')
print('testX_shape:{}\ntestY_shape:{}'.format(testX.shape, testY.shape))
Xtrain, Xvalid, Ytrain, Yvalid = train_test_split(trainX,
trainY,
test_size=0.1,
random_state=43)
# Define model
models = []
for i in range(args.nmodel):
print('model{}:'.format(i))
models.append(create_3dcnn(Xtrain.shape[1:], nb_classes))
models[-1].compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
history = models[-1].fit(Xtrain,
Ytrain,
validation_data=(Xvalid, Yvalid),
batch_size=args.batch,
nb_epoch=args.epoch,
verbose=1,
shuffle=True)
plot_history(history, args.output, i)
save_history(history, args.output, i)
model_inputs = [Input(shape=Xtrain.shape[1:]) for _ in range(args.nmodel)]
model_outputs = [models[i](model_inputs[i]) for i in range(args.nmodel)]
model_outputs = average(inputs=model_outputs)
model = Model(inputs=model_inputs, outputs=model_outputs)
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
#model.summary()
#plot_model(model, show_shapes=True,
# to_file=os.path.join(args.output, 'model.png'))
model_json = model.to_json()
with open(os.path.join(args.output, 'ucf101_3dcnnmodel_ensemble.json'),
'w') as json_file:
json_file.write(model_json)
model.save_weights(
os.path.join(args.output, 'ucf101_3dcnnmodel_ensemble.hd5'))
loss, acc = model.evaluate([testX] * args.nmodel, testY, verbose=0)
with open(os.path.join(args.output, 'result.txt'), 'w') as f:
f.write('Test loss: {}\nTest accuracy:{}'.format(loss, acc))
print('merged model:')
print('Test loss:', loss)
print('Test accuracy:', acc)
def main():
# model = load_model('ucf101-dq/2019-09-08 16:24:35_74_10_0.8191161358466741_ucf101_3dcnnmodel.hd5')
with open('ucf101-dq/2019-09-12 13:52:44_101_10_ucf101_3dcnnmodel.json',
'r') as model_json:
model = model_from_json(model_json.read(), custom_objects={'tf': tf})
model.load_weights(
'ucf101-dq/2019-09-12 13:52:44_101_10_ucf101_3dcnnmodel.hd5')
model.summary()
vid3d = videoto3d.Videoto3D(64, 64, 10, 'files_in_one_dir')
layer_dict = dict([(layer.name, layer) for layer in model.layers])
# images=cv2.imread("../Project/1.jpg")
images = []
images.append(
vid3d.video3d('/data/nfs/UCF-101/v_JugglingBalls_g09_c01.avi',
color=True,
skip=True))
images = np.array(images).transpose((0, 2, 3, 1, 4))
# cv2.imshow("Image", images)
# cv2.waitKey(0)
# Turn the image into an array.
# 根据载入的训练好的模型的配置，将图像统一尺寸
# image_arr = cv2.resize(images, (70, 70))
# image_arr = np.expand_dims(image_arr, axis=0)
# 第一个 model.layers[0],不修改,表示输入数据；
# 第二个model.layers[ ],修改为需要输出的层数的编号[]
# layer_1 = K.function([model.layers[0].input], [model.layers[1].output])
layer_mask = K.function([layer_dict['input_1'].input],
[layer_dict['multiply_1'].output])
# 只修改inpu_image
f1 = layer_mask([images])[0]
# 第一层卷积后的特征图展示，输出是（1,66,66,32），（样本个数，特征图尺寸长，特征图尺寸宽，特征图个数）
f1 = f1.squeeze(axis=0)
for _ in range(5):
show_img = f1[:, :, _, :]
# show_img = show_img.squeeze(axis=2)
plt.subplot(2, 5, _ + 1)
# plt.imshow(show_img, cmap='black')
# plt.imshow(show_img, cmap='gray')
plt.imshow(show_img.astype(np.int))
plt.subplot(2, 5, 5 + _ + 1)
plt.imshow(np.array(images[:, :, :, _, :]).squeeze(axis=0))
plt.axis('off')
# plt.subplot(2,6,12)
# plt.imshow(np.array(images[:,:,:,5,:]).squeeze(axis=0))
plt.show()
plt.figure(2)
for _ in range(5):
show_img = f1[:, :, 5 + _, :]
# show_img = show_img.squeeze(axis=2)
plt.subplot(2, 5, _ + 1)
# plt.imshow(show_img, cmap='black')
# plt.imshow(show_img, cmap='gray')
plt.imshow(show_img.astype(np.int))
plt.subplot(2, 5, 5 + _ + 1)
plt.imshow(np.array(images[:, :, :, 5 + _, :]).squeeze(axis=0))
plt.axis('off')
plt.show()
labellist.append(label)
labels.append(label)
X.append(vid3d.video3d(v_file_path, color=color, skip=skip))
if color:
return np.array(X).transpose((0, 2, 3, 4, 1)), labels
else:
return np.array(X).transpose((0, 2, 3, 1)), labels
img_rows, img_cols, frames = 32, 32, 10
channel = 3
vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
x, y = loaddata('Test', vid3d, 10, 'Output', 3, True)
print("Inside Else")
X = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
X = X.astype('float32')
model = load_model('d_3dcnnmodel-36-0.97.hd5')
print(model.summary())
y_pred = model.predict(X)
print(y_pred)
print(np.argmax(y_pred))
def main():
import pynvml
pynvml.nvmlInit()
# 这里的0是GPU id
handle2 = pynvml.nvmlDeviceGetHandleByIndex(2)
handle3 = pynvml.nvmlDeviceGetHandleByIndex(3)
# meminfo = pynvml.nvmlDeviceGetMemoryInfo(handle)
# print(meminfo.used)
parser = argparse.ArgumentParser(
description='simple 3D convolution for action recognition')
parser.add_argument('--batch', type=int, default=128)
parser.add_argument('--epoch', type=int, default=100)
parser.add_argument('--videos',
type=str,
default='UCF101',
help='directory where videos are stored')
parser.add_argument('--nclass', type=int, default=101)
parser.add_argument('--output', type=str, required=True)
parser.add_argument('--color', type=bool, default=False)
parser.add_argument('--skip', type=bool, default=True)
parser.add_argument('--depth', type=int, default=10)
parser.add_argument('--dataset', type=str, default='ucf101')
args = parser.parse_args()
img_rows, img_cols, frames = 64, 64, args.depth
channel = 3 if args.color else 1
fname_npz = 'dataset_{}_{}_{}_{}.npz'.format(args.dataset, args.nclass,
args.depth, args.skip)
vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames, args.dataset)
nb_classes = args.nclass
if os.path.exists(fname_npz):
loadeddata = np.load(fname_npz)
X, Y = loadeddata["X"], loadeddata["Y"]
else:
x, y = loaddata(args.videos, vid3d, args.nclass, args.output,
args.dataset, frames, args.color, args.skip)
X = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
Y = np_utils.to_categorical(y, nb_classes)
X = X.astype('float32')
np.savez(fname_npz, X=X, Y=Y)
print('Saved dataset to dataset.npz.')
print('X_shape:{}\nY_shape:{}'.format(X.shape, Y.shape))
# Define model
# conv3D + Relu + Conv3D + Softmax + Pooling3D + DropOut
input_x = Input(shape=(img_rows, img_cols, frames, channel))
#
# # C3D-conv1
# convLayer = Conv3D(32, kernel_size= (3, 3, 3),padding='same')(input_x)
# convLayer = ReLU()(convLayer)
#
# convLayer = Conv3D(32, kernel_size= (3, 3, 3), padding='same')(convLayer)
# convLayer = Softmax()(convLayer)
# convLayer = MaxPooling3D(pool_size=(3,3,3), padding='same')(convLayer)
# convLayer = Dropout(0.25)(convLayer)
#
# # C3D-conv2
# convLayer = Conv3D(64, kernel_size= (3, 3, 3),padding='same')(convLayer)
# convLayer = ReLU()(convLayer)
#
# convLayer = Conv3D(64, kernel_size= (3, 3, 3), padding='same')(convLayer)
# convLayer = Softmax()(convLayer)
# convLayer = MaxPooling3D(pool_size=(3,3,3), padding='same')(convLayer)
# convLayer = Dropout(0.25)(convLayer)
#
#
# maskLayer = Conv3D(64*frames, kernel_size=(3,3,2), padding='same')(convLayer)
# maskLayer = Lambda(mean_filter)(maskLayer) # [None,1, 64], each point represent a mask of input region of 8x8 points
# # maskLayer = BatchNormalization()(maskLayer)
# maskLayer = Lambda(K.sigmoid)(maskLayer)
# # maskLayer = ReLU()(maskLayer)
# # maskLayer = Lambda(bi_trans, arguments={'th':0.5})(maskLayer)
# maskLayer = Reshape(( 8, 8, frames, 1))(maskLayer) #reshape_filter(maskLayer, shape=[None,8,8,1,1])
# # maskLayer = Lambda(normalize)(maskLayer)
# maskLayerForLoss = maskLayer
# maskLayer = Lambda(repeat_filter,arguments={'rep':8, 'axis':1})(maskLayer)
# maskLayer = Lambda(repeat_filter,arguments={'rep':8, 'axis':2})(maskLayer)
# # maskLayer = Lambda(repeat_filter,arguments={'rep':frames, 'axis':3})(maskLayer)
# maskLayer = Lambda(repeat_filter,arguments={'rep':channel, 'axis':4})(maskLayer)
#
# # maskLayer = Lambda(repeat_filter,arguments={'rep':2, 'axis':3})(maskLayer)
# # maskLayer = Lambda(repeat_filter,arguments={'rep':64, 'axis':4})(maskLayer)
#
#
# convLayer = Multiply()([maskLayer,input_x])
#
#
# C3D-conv1
convLayer = Conv3D(32, kernel_size=(3, 3, 3), padding='same')(input_x)
convLayer = ReLU()(convLayer)
convLayer = Conv3D(32, kernel_size=(3, 3, 3), padding='same')(convLayer)
convLayer = Softmax()(convLayer)
convLayer = MaxPooling3D(pool_size=(3, 3, 3), padding='same')(convLayer)
convLayer = Dropout(0.25)(convLayer)
# C3D-conv2
convLayer = Conv3D(64, kernel_size=(3, 3, 3), padding='same')(convLayer)
convLayer = ReLU()(convLayer)
convLayer = Conv3D(64, kernel_size=(3, 3, 3), padding='same')(convLayer)
convLayer = Softmax()(convLayer)
convLayer = MaxPooling3D(pool_size=(3, 3, 3), padding='same')(convLayer)
convLayer = Dropout(0.25)(convLayer)
fc1 = Flatten()(convLayer)
fc = Dense(512, activation='sigmoid')(fc1)
fc = Dropout(0.5)(fc)
dense_out = Dense(nb_classes, activation='softmax')(fc)
dense_out_converse = Dense(nb_classes)(fc)
# model = Model(input_x, [dense_out, dense_out_converse])
model = Model(input_x, [dense_out, dense_out_converse])
# loss of 2 parts
losses = {'dense_2': K.categorical_crossentropy, 'dense_3': unlikely_loss}
lossWeights = {'dense_2': 1, 'dense_3': 1}
model.compile(loss=losses,
loss_weights=lossWeights,
optimizer=Adam(lr=0.001),
metrics=['accuracy'])
# model.compile(loss=categorical_crossentropy, optimizer=Adam(lr=0.001),metrics=['accuracy'])
model.summary()
plot_model(model,
show_shapes=True,
to_file=os.path.join(args.output, 'model.png'))
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
test_size=0.1,
random_state=43)
X_train, X_val, Y_train, Y_val = train_test_split(X_train,
Y_train,
test_size=0.1,
random_state=43)
# history = model.fit_generator(myGenerator(X_train, X_test, Y_train, Y_test, nb_classes, args.batch),
# samples_per_epoch=X_train.shape[0], epochs=args.epoch, verbose=1,
# callbacks=callbacks_list,
# shuffle=True)
# check GPUs status , once a GPU is available, change os environment parameters and break
# is none of the GPUs are ready ,sleep for 2 secs and retry.
cnt = 0
while True:
cnt += 1
processinfo = pynvml.nvmlDeviceGetComputeRunningProcesses(handle2)
if len(processinfo) == 0:
os.environ['CUDA_VISIBLE_DEVICES'] = '2'
print('GPU 2 is available, use GPU 2\n')
break
processinfo = pynvml.nvmlDeviceGetComputeRunningProcesses(handle3)
if len(processinfo) == 0:
os.environ['CUDA_VISIBLE_DEVICES'] = '3'
print('GPU 3 is available, use GPU 3\n')
break
sleep(2)
print('\rretry time: {}'.format(cnt), end='')
history = model.fit(X_train, [Y_train, Y_train],
validation_data=(X_val, [Y_val, Y_val]),
batch_size=args.batch,
epochs=args.epoch,
verbose=1,
shuffle=True)
# history = model.fit(X_train, Y_train,
# validation_data=(X_val, Y_val),
# batch_size=args.batch,
# epochs=args.epoch, verbose=1, shuffle=True)
# loss, acc = model.evaluate(X_test, Y_test, verbose=0)
model_json = model.to_json()
if not os.path.isdir(args.output):
os.makedirs(args.output)
with open(
os.path.join(
args.output, '{}_{}_{}_ucf101_3dcnnmodel.json'.format(
current_time, nb_classes, args.depth)), 'w') as json_file:
json_file.write(model_json)
model.save_weights(
os.path.join(
args.output,
'{}_{}_{}_ucf101_3dcnnmodel.hd5'.format(current_time, nb_classes,
args.depth)))
loss = model.evaluate(X_test, [Y_test, Y_test], verbose=0)
# loss, acc = model.evaluate(X_test, Y_test, verbose=0)
print('Test loss:', loss)
plot_history(history, args.output)
save_history(history, args.output)
print('Test loss:', loss)
def main():
parser = argparse.ArgumentParser(description='2D convolution')
parser.add_argument('--batch', type=int, default=128)
parser.add_argument('--epoch', type=int, default=100)
parser.add_argument('--videos',
type=str,
default='videos',
help='directory where videos are stored')
parser.add_argument('--nclass', type=int, default=101)
parser.add_argument('--output', type=str, required=True)
args = parser.parse_args()
img_rows, img_cols = 32, 32
vid3d = videoto3d.Videoto3D(img_rows, img_cols, 1)
x, y = loaddata(args.videos, vid3d, args.nclass, args.output)
X = x.reshape(x.shape[0], img_cols, img_rows, 1)
nb_classes = max(y) + 1
Y = np_utils.to_categorical(y, nb_classes)
X = X.astype('float32')
print('X shape:{}\nYshape:{}'.format(X.shape, Y.shape))
# define model
model = Sequential()
model.add(
Convolution2D(32, 3, 3, border_mode='same', input_shape=X.shape[1:]))
model.add(Activation('relu'))
model.add(Convolution2D(32, 3, 3))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Convolution2D(64, 3, 3, border_mode='same'))
model.add(Activation('relu'))
model.add(Convolution2D(64, 3, 3))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.summary()
plot_model(model,
show_shapes=True,
to_file=os.path.join(args.output, 'model.png'))
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
test_size=0.2,
random_state=4)
history = model.fit(X_train,
Y_train,
batch_size=args.batch,
nb_epoch=args.epoch,
validation_data=(X_test, Y_test),
shuffle=True)
model_json = model.to_json()
with open(os.path.join(args.output, 'ucf101cnnmodel.json'),
'w') as json_file:
json_file.write(model_json)
model.save_weights(os.path.join(args.output, 'ucf101cnnmodel.hd5'))
loss, acc = model.evaluate(X_test, Y_test, verbose=0)
print('Test loss:', loss)
print('Test accuracy:', acc)
plot_history(history, args.output)
save_history(history, args.output)
def main():
parser = argparse.ArgumentParser(
description='simple 3D convolution for action recognition')
parser.add_argument('--batch', type=int, default=128)
parser.add_argument('--epoch', type=int, default=100)
parser.add_argument('--videos',
type=str,
default='UCF101',
help='directory where videos are stored')
parser.add_argument('--nclass', type=int, default=101)
parser.add_argument('--output', type=str, required=True)
parser.add_argument('--color', type=bool, default=False)
parser.add_argument('--skip', type=bool, default=True)
parser.add_argument('--depth', type=int, default=10)
args = parser.parse_args()
img_rows, img_cols, frames = 32, 32, args.depth
channel = 3 if args.color else 1
vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames)
x, y = loaddata(args.videos, vid3d, args.nclass, args.output, args.color,
args.skip)
X = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
nb_classes = max(y) + 1
Y = np_utils.to_categorical(y, nb_classes)
X = X.astype('float32')
print('X_shape:{}\nY_shape:{}'.format(X.shape, Y.shape))
# Define model
model = Sequential()
model.add(
Convolution3D(32,
kernel_dim1=3,
kernel_dim2=3,
kernel_dim3=3,
input_shape=(X.shape[1:]),
border_mode='same',
activation='relu'))
model.add(
Convolution3D(32,
kernel_dim1=3,
kernel_dim2=3,
kernel_dim3=3,
border_mode='same',
activation='relu'))
model.add(MaxPooling3D(pool_size=(3, 3, 3), border_mode='same'))
model.add(Dropout(0.25))
model.add(
Convolution3D(64,
kernel_dim1=3,
kernel_dim2=3,
kernel_dim3=3,
border_mode='same',
activation='relu'))
model.add(
Convolution3D(64,
kernel_dim1=3,
kernel_dim2=3,
kernel_dim3=3,
border_mode='same',
activation='relu'))
model.add(MaxPooling3D(pool_size=(3, 3, 3), border_mode='same'))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(512, init='normal', activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes, init='normal'))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.summary()
plot(model,
show_shapes=True,
to_file=os.path.join(args.output, 'model.png'))
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
test_size=0.2,
random_state=4)
histoinry = model.fit(X_train,
Y_train,
validation_data=(X_test, Y_test),
batch_size=args.batch,
nb_epoch=args.epoch,
verbose=1,
shuffle=True)
model.evaluate(X_test, Y_test, verbose=0)
model_json = model.to_json()
with open(os.path.join(args.output, 'ucf101_3dcnnmodel.json'),
'w') as json_file:
json_file.write(model_json)
model.save_weights(os.path.join(args.output, 'ucf101_3dcnnmodel.hd5'))
loss, acc = model.evaluate(X_test, Y_test, verbose=0)
print('Test loss:', loss)
print('Test accuracy:', acc)
plot_history(history, args.output)
save_history(history, args.output)
