def TranslateModel(
cls,
caffe_net,
pretrained_net,
is_test=False,
net_state=None,
remove_legacy_pad=False,
input_dims=None
):
net_state = caffe_pb2.NetState() if net_state is None else net_state
net = caffe2_pb2.NetDef()
net.name = caffe_net.name
net_params = caffe2_pb2.TensorProtos()
if len(caffe_net.layers) > 0:
raise ValueError(
'I think something is wrong. This translation script '
'only accepts new style layers that are stored in the '
'layer field.'
)
if not input_dims:
input_dims = _GetInputDims(caffe_net)
for layer in caffe_net.layer:
if not _ShouldInclude(net_state, layer):
log.info('Current net state does not need layer {}'
.format(layer.name))
continue
log.info('Translate layer {}'.format(layer.name))
# Get pretrained one
pretrained_layers = (
[l for l in pretrained_net.layer
if l.name == layer.name] + [l
for l in pretrained_net.layers
if l.name == layer.name]
)
if len(pretrained_layers) > 1:
raise ValueError(
'huh? more than one pretrained layer of one name?')
elif len(pretrained_layers) == 1:
pretrained_blobs = [
utils.CaffeBlobToNumpyArray(blob)
for blob in pretrained_layers[0].blobs
]
else:
# No pretrained layer for the given layer name. We'll just pass
# no parameter blobs.
# print 'No pretrained layer for layer', layer.name
pretrained_blobs = []
operators, params = cls.TranslateLayer(
layer, pretrained_blobs, is_test, net=net,
net_params=net_params, input_dims=input_dims)
net.op.extend(operators)
net_params.protos.extend(params)
if remove_legacy_pad:
assert input_dims, \
'Please specify input_dims to remove legacy_pad'
net = _RemoveLegacyPad(net, net_params, input_dims)
return net, net_params
def _create_test_tensor_protos(self, idx):
item = caffe2_pb2.TensorProtos()
data = item.protos.add()
data.data_type = core.DataType.STRING
data.string_data.append("foo{}".format(idx).encode('utf-8'))
label = item.protos.add()
label.data_type = core.DataType.INT32
label.int32_data.append(1)
return item.SerializeToString()
def decode_msg(databuf):
if databuf is None :
return None
tensor_protos = caffe2_pb2.TensorProtos()
tensor_protos.ParseFromString(databuf)
img_proto=tensor_protos.protos[0]
imgbuf=img_proto.string_data[0]
dataArray = np.frombuffer(imgbuf, np.uint8)
dataArray=dataArray.reshape(img_proto.dims)
return dataArray
def write_lmdb(labels_file_path, lmdb_path):
invalid = []
valid = []
labels_handler = open(labels_file_path, "r")
# Write to lmdb
print(">>> Write database...")
LMDB_MAP_SIZE = 1 << 40
print("LMDB_MAP_SIZE", LMDB_MAP_SIZE)
env = lmdb.open(lmdb_path, map_size=LMDB_MAP_SIZE)
with env.begin(write=True) as txn:
count = 0
for line in labels_handler.readlines():
line = line.rstrip()
clip_path = line.split()[0]
clip_label = int(line.split()[1])
# read in image (as multichannel pose motion representation)
# print(clip_path)
potion_data = PoTion(clip_path, img_size=(height, width), ch=col_ch, sigma=sigma, scale=resize_scale)
if potion_data is not None:
count = count + 1
valid.append(line)
# Create TensorProtos
tensor_protos = caffe2_pb2.TensorProtos()
potion_tensor = tensor_protos.protos.add()
potion_tensor.dims.extend(potion_data.shape)
potion_tensor.data_type = 1
flatten_potion = potion_data.reshape(np.prod(potion_data.shape))
potion_tensor.float_data.extend(flatten_potion)
label_tensor = tensor_protos.protos.add()
label_tensor.data_type = 2
label_tensor.int32_data.append(clip_label)
fileId_tensor = tensor_protos.protos.add()
fileId_tensor.data_type=2
fileId_tensor.int32_data.append(count)
txn.put(
'{}'.format(count).encode('ascii'),
tensor_protos.SerializeToString()
)
if ((count % 1000 == 0)):
print("Inserted {} rows".format(count))
else:
# print('data was invalid, is removed')
invalid.append(line)
print("Inserted {} rows".format(count))
print("\nLMDB saved at " + lmdb_path + "\n\n")
labels_handler.close()
return invalid, valid
def write_db(db_type, db_name, features, labels):
db = core.C.create_db(db_type, db_name, core.C.Mode.write)
transaction = db.new_transaction()
for i in range(features.shape[0]):
feature_and_label = caffe2_pb2.TensorProtos()
feature_and_label.protos.extend([
utils.NumpyArrayToCaffe2Tensor(features[i]),
utils.NumpyArrayToCaffe2Tensor(labels[i])
])
transaction.put('train_%03d'.format(i),
feature_and_label.SerializeToString())
# Close the transaction, and then close the db.
del transaction
del db
def make_datum(img_data, label):
# Create TensorProtos
tensor_protos = caffe2_pb2.TensorProtos()
img_tensor = tensor_protos.protos.add()
img_tensor.dims.extend(img_data.shape)
img_tensor.data_type = 1
flatten_img = img_data.reshape(np.prod(img_data.shape))
img_tensor.float_data.extend(flatten_img)
label_tensor = tensor_protos.protos.add()
label_tensor.data_type = 2
label_tensor.int32_data.append(label)
return tensor_protos
def write_db(db_type, db_name, data_lst):
''' The minidb datebase seems immutable.
'''
db = core.C.create_db(db_type, db_name, core.C.Mode.write)
transaction = db.new_transaction()
for i in range(data_lst[0].shape[0]):
tensor = caffe2_pb2.TensorProtos()
temp_lst = []
for data in data_lst:
temp_lst.append(utils.NumpyArrayToCaffe2Tensor(data[i]))
tensor.protos.extend(temp_lst)
transaction.put(str(i), tensor.SerializeToString())
del transaction
del db
return db_name
def insert_db(db_name, data, labels):
db_type = db_name.split(".")[-1]
db = core.C.create_db(db_type, db_name, core.C.Mode.write)
transaction = db.new_transaction()
for i in range(data.shape[0]):
data_and_label = caffe2_pb2.TensorProtos()
data_and_label.protos.extend([
utils.NumpyArrayToCaffe2Tensor(data[i]),
utils.NumpyArrayToCaffe2Tensor(labels[i])
])
transaction.put('data_%03d'.format(i),
data_and_label.SerializeToString())
# Close the transaction, and then close the db.
del transaction
del db
def write_lmdb(labels_file_path, lmdb_path):
with open(labels_file_path, "r") as labels_handler:
print(">>> Write database...")
LMDB_MAP_SIZE = 1 << 40 # ????
print("LMDB_MAP_SIZE", LMDB_MAP_SIZE)
env = lmdb.open(lmdb_path, map_size=LMDB_MAP_SIZE)
with env.begin(write=True) as txn:
count = 0
for line in labels_handler.readlines():
line = line.rstrip()
im_path = line.split()[0]
im_label = int(line.split()[1])
# read in image (as RGB)
img_data = imread(im_path).astype(np.float32)
# convert to BGR
img_data = img_data[:, :, (2, 1, 0)]
img_data = img_data / 256.0
# HWC -> CHW (N gets added in AddInput function)
img_data = np.transpose(img_data, (2, 0, 1))
# Create TensorProtos
tensor_protos = caffe2_pb2.TensorProtos()
img_tensor = tensor_protos.protos.add()
img_tensor.dims.extend(img_data.shape)
img_tensor.data_type = 1
flatten_img = img_data.reshape(np.prod(img_data.shape))
img_tensor.float_data.extend(flatten_img)
label_tensor = tensor_protos.protos.add()
label_tensor.data_type = 2
label_tensor.int32_data.append(im_label)
# write to db
txn.put(
"{}".format(count).encode("ascii"), # key
tensor_protos.SerializeToString() # value
)
if count % 1000 == 0:
print("Inserted {} rows".format(count))
count = count + 1
print("Inserted {} rows".format(count))
print("\nLMDB saved at " + lmdb_path)
def encode_msg(msg):
if msg is None :
return None
# Create TensorProtos
msg = msg.astype( np.uint8)
tensor_protos = caffe2_pb2.TensorProtos()
img_tensor = tensor_protos.protos.add()
img_tensor.dims.extend(msg.shape)
img_tensor.data_type = 4
img_tensor.name = str(msg.shape)
flatten_img = msg.reshape(np.prod(msg.shape))
img_tensor.name = str(msg.shape)+"----"+str(flatten_img.shape)
img_tensor.string_data.append(flatten_img.tostring())
return tensor_protos.SerializeToString()
def create_video_db(self, list_file, output_file, use_list=False):
# Write to lmdb database...
LMDB_MAP_SIZE = 1 << 40 # MODIFY
env = lmdb.open(output_file, map_size=LMDB_MAP_SIZE)
total_size = 0
file_name = []
start_frame = []
label = []
index = 0
with env.begin(write=True) as txn:
with open(list_file, "r") as data:
for line in data:
p = line.split()
file_name = p[0]
start_frame = int(p[1])
label = int(p[2])
if not use_list:
with open(file_name, mode="rb") as file:
video_data = file.read()
else:
video_data = file_name
tensor_protos = caffe2_pb2.TensorProtos()
video_tensor = tensor_protos.protos.add()
video_tensor.data_type = 4 # string data
video_tensor.string_data.append(video_data)
label_tensor = tensor_protos.protos.add()
label_tensor.data_type = 2
label_tensor.int32_data.append(label)
start_frame_tensor = tensor_protos.protos.add()
start_frame_tensor.data_type = 2
start_frame_tensor.int32_data.append(start_frame)
txn.put(
"{}".format(index).encode("ascii"),
tensor_protos.SerializeToString(),
)
index = index + 1
total_size = total_size + len(video_data) + sys.getsizeof(
int)
return total_size
def make_lmdb(data, labels, output_file, data_shape=None):
print(">>> write database...")
LMDB_MAP_SIZE = 3 * (1 << 30)
env = lmdb.open(output_file, LMDB_MAP_SIZE)
dt_shape = None
if type(data) is np.array:
dt_shape = data.shape
elif data_shape is None:
logging.error("data_shape is required,exit!")
return
else:
dt_shape = data_shape
with env.begin(write=True) as txn:
if len(data) != len(labels):
logging.error("data and labels do not match")
raise Exception("mismatched data and labels")
try:
for index in xrange(len(data)):
image_protos = caffe2_pb2.TensorProtos()
image_proto = image_protos.protos.add()
image_proto.data_type = caffe2_pb2.TensorProto.FLOAT
image_proto.dims.extend(dt_shape)
dt = None
if type(data) is np.array:
dt = data[index].reshape(np.prod(dt_shape))
else:
dt = data[index]
image_proto.float_data.extend(dt)
label_proto = image_protos.protos.add()
label_proto.data_type = caffe2_pb2.TensorProto.INT32
label_proto.int32_data.append(labels[index])
txn.put('{}'.format(index).encode("ascii"),
image_protos.SerializeToString())
if index % 16 == 0:
logging.info('Inserted {} rows'.format(index))
except Exception as _e:
logging.error("excetion traceback: %s", traceback.format_exc())
return
def write_db(db_type, db_name, input_file):
db = core.C.create_db(db_type, db_name, core.C.Mode.write)
transaction = db.new_transaction()
with open(input_file,'r') as f:
data_paths = f.readlines()
for j in range(len(data_paths)):
img_path = data_paths[j].split(' ')[0]
print(j,img_path)
label = np.array(int(data_paths[j].split(' ')[1][0]))
img = skimage.img_as_float(skimage.io.imread(img_path))
img = skimage.transform.resize(img,(224,224))
img = img[:,:,(2,1,0)]
img_data = img.transpose(2,0,1)
feature_and_label = caffe2_pb2.TensorProtos()
feature_and_label.protos.extend([utils.NumpyArrayToCaffe2Tensor(img_data), utils.NumpyArrayToCaffe2Tensor(label)])
transaction.put('train_%04d'.format(j),feature_and_label.SerializeToString())
del transaction
del db
def TranslateModel(
cls,
caffe_net,
pretrained_net,
net_state=caffe_pb2.NetState()
):
net = caffe2_pb2.NetDef()
net.name = caffe_net.name
net_params = caffe2_pb2.TensorProtos()
if len(caffe_net.layer) == 0:
raise ValueError(
'I think something is wrong. This translation script '
'only accepts new style layers that are stored in the '
'layer field.'
)
for layer in caffe_net.layer:
if not _ShouldInclude(net_state, layer):
print 'Current net state does not need layer', layer.name
continue
print 'Translate layer', layer.name
# Get pretrained one
pretrained_layers = (
[l for l in pretrained_net.layer
if l.name == layer.name] + [l
for l in pretrained_net.layers
if l.name == layer.name]
)
if len(pretrained_layers) > 1:
raise ValueError(
'huh? more than one pretrained layer of one name?')
elif len(pretrained_layers) == 1:
pretrained_blobs = [
utils.CaffeBlobToNumpyArray(blob)
for blob in pretrained_layers[0].blobs
]
else:
# No pretrained layer for the given layer name. We'll just pass
# no parameter blobs.
# print 'No pretrained layer for layer', layer.name
pretrained_blobs = []
operators, params = cls.TranslateLayer(layer, pretrained_blobs)
net.op.extend(operators)
net_params.protos.extend(params)
return net, net_params
def insert_image_to_lmdb(img_data, label, index):
# Create TensorProtos
tensor_protos = caffe2_pb2.TensorProtos()
img_tensor = tensor_protos.protos.add()
img_tensor.dims.extend(img_data.shape)
img_tensor.data_type = 1
flatten_img = img_data.reshape(np.prod(img_data.shape))
img_tensor.float_data.extend(flatten_img)
label_tensor = tensor_protos.protos.add()
label_tensor.data_type = 2
label_tensor.int32_data.append(label)
txn.put(
'{}'.format(index).encode('ascii'),
tensor_protos.SerializeToString()
)
if ((index % 100 == 0)):
print("Inserted {} rows".format(index))
index = index + 1
return index
def write_caffe_db(db_type, db_name, folder, filetype):
db = core.C.create_db(db_type, db_name, core.C.Mode.write)
transaction = db.new_transaction()
i = 0
filename = folder + '/*.' + filetype
for filename in glob.glob(filename): #assuming gif
im = skimage.img_as_float(skimage.io.imread(filename)).astype(np.float32)
img256 = skimage.transform.resize(img, w_size, y_size))
img256 = img256.swapaxes(1, 2).swapaxes(0, 1)
img256 = img256[(2, 1, 0), :, :]
lab = np.array(0, dtype = "int64")
feature_and_label = caffe2_pb2.TensorProtos()
feature_and_label.protos.extend([
utils.NumpyArrayToCaffe2Tensor(img256),
utils.NumpyArrayToCaffe2Tensor(lab)
])
transaction.put(
'train_%03d'.format(i),
feature_and_label.SerializeToString())
i += 1
def create_db(output_file):
print(">>> Write database...")
LMDB_MAP_SIZE = 1 << 40 # MODIFY
env = lmdb.open(output_file, map_size=LMDB_MAP_SIZE)
checksum = 0
with env.begin(write=True) as txn:
for j in range(0, 128):
# MODIFY: add your own data reader / creator
label = j % 10
width = 64
height = 32
img_data = np.random.rand(3, width, height)
# ...
# Create TensorProtos
tensor_protos = caffe2_pb2.TensorProtos()
img_tensor = tensor_protos.protos.add()
img_tensor.dims.extend(img_data.shape)
img_tensor.data_type = 1
flatten_img = img_data.reshape(np.prod(img_data.shape))
img_tensor.float_data.extend(flatten_img)
label_tensor = tensor_protos.protos.add()
label_tensor.data_type = 2
label_tensor.int32_data.append(label)
txn.put('{}'.format(j).encode('ascii'),
tensor_protos.SerializeToString())
checksum += np.sum(img_data) * label
if (j % 16 == 0):
print("Inserted {} rows".format(j))
print("Checksum/write: {}".format(int(checksum)))
return checksum
def create_test(output_dir, width, height, default_bound, minsize, crop, means,
stds, count, label_type, num_labels, output1=None,
output2_size=None):
print("Creating a temporary lmdb database of %d pictures..." % (count))
if default_bound is None:
default_bound = [-1] * 4
LMDB_MAP_SIZE = 1 << 40
env = lmdb.open(output_dir, map_size=LMDB_MAP_SIZE, subdir=True)
index = 0
# Create images and the expected results
expected_results = []
with env.begin(write=True) as txn:
while index < count:
img_array = np.random.random_integers(
0, 255, [height, width, 3]).astype(np.uint8)
img_obj = Image.fromarray(img_array)
img_str = StringIO.StringIO()
img_obj.save(img_str, 'PNG')
# Create a random bounding box for every other image
# ymin, xmin, bound_height, bound_width
# TODO: To ensure that we never need to scale, we
# ensure that the bounding-box is larger than the
# minsize parameter
bounding_box = list(default_bound)
do_default_bound = True
if index % 2 == 0:
if height > minsize and width > minsize:
do_default_bound = False
bounding_box[0:2] = [np.random.randint(a) for a in
(height - minsize, width - minsize)]
bounding_box[2:4] = [np.random.randint(a) + minsize for a in
(height - bounding_box[0] - minsize + 1,
width - bounding_box[1] - minsize + 1)]
# print("Bounding box is %s" % (str(bounding_box)))
# Create expected result
img_expected = img_array.astype(np.float32) * (1.0 / 255.0)
# print("Orig image: %s" % (str(caffe2_img(img_expected))))
img_expected = verify_apply_bounding_box(
img_expected,
bounding_box)
# print("Bounded image: %s" % (str(caffe2_img(img_expected))))
img_expected = verify_rescale(img_expected, minsize)
img_expected = verify_crop(img_expected, crop)
# print("Crop image: %s" % (str(caffe2_img(img_expected))))
img_expected = verify_color_normalize(img_expected, means, stds)
# print("Color image: %s" % (str(caffe2_img(img_expected))))
tensor_protos = caffe2_pb2.TensorProtos()
image_tensor = tensor_protos.protos.add()
image_tensor.data_type = 4 # string data
image_tensor.string_data.append(img_str.getvalue())
img_str.close()
label_tensor = tensor_protos.protos.add()
label_tensor.data_type = 2 # int32 data
assert (label_type >= 0 and label_type <= 2)
if label_type == 0:
label_tensor.int32_data.append(index)
expected_label = index
elif label_type == 1:
binary_labels = np.random.randint(2, size=num_labels)
for idx, val in enumerate(binary_labels.tolist()):
if val == 1:
label_tensor.int32_data.append(idx)
expected_label = binary_labels
elif label_type == 2:
embedding_label = np.random.randint(100, size=num_labels)
for _idx, val in enumerate(embedding_label.tolist()):
label_tensor.int32_data.append(val)
expected_label = embedding_label
if output1:
output1_tensor = tensor_protos.protos.add()
output1_tensor.data_type = 1 # float data
output1_tensor.float_data.append(output1)
output2 = []
if output2_size:
output2_tensor = tensor_protos.protos.add()
output2_tensor.data_type = 2 # int32 data
values = np.random.randint(1024, size=output2_size)
for val in values.tolist():
output2.append(val)
output2_tensor.int32_data.append(val)
expected_results.append(
[caffe2_img(img_expected), expected_label, output1, output2])
if not do_default_bound:
bounding_tensor = tensor_protos.protos.add()
bounding_tensor.data_type = 2 # int32 data
bounding_tensor.int32_data.extend(bounding_box)
txn.put(
'{}'.format(index).encode('ascii'),
tensor_protos.SerializeToString()
)
index = index + 1
# End while
# End with
return expected_results
def create_an_lmdb_database(list_file, output_file, use_local_file=True):
print("Write video to a lmdb...")
LMDB_MAP_SIZE = 1 << 40 # MODIFY
env = lmdb.open(output_file, map_size=LMDB_MAP_SIZE)
# start counters
total_size = 0
index = 0
test_start_frame_num = 10
crop_times = 6
# initialize empty lists
list_idx = []
list_file_name = []
# list_start_frame = []
list_label_strings = []
# read in a list and shuffle
items = 0
with open(list_file, 'r') as data:
for line in data:
tokens = line.split()
list_file_name.append(tokens[0])
# list_start_frame.append(int(tokens[1]))
list_label_strings.append(tokens[1])
list_idx.append(items)
items = items + 1
with env.begin(write=True) as txn:
for i in range(items):
if not use_local_file:
# read raw video data and store to db
with open(list_file_name[list_idx[i]], mode='rb') as file:
video_data = file.read()
else:
# store the full path to local video file
video_data = list_file_name[list_idx[i]]
if i % 1000 == 0:
print(i)
for ct in range(crop_times):
for j in range(test_start_frame_num):
tensor_protos = caffe2_pb2.TensorProtos()
video_tensor = tensor_protos.protos.add()
video_tensor.data_type = 4 # string data
video_tensor.string_data.append(video_data)
label_tensor = tensor_protos.protos.add()
label_tensor.data_type = 2
label_string = list_label_strings[list_idx[i]]
labels = label_string.split(',')
label_tensor.int32_data.append(i)
# for label in labels:
# label_tensor.int32_data.append(int(label))
start_frame_tensor = tensor_protos.protos.add()
start_frame_tensor.data_type = 2
start_frame_tensor.int32_data.append(j)
spatial_pos_tensor = tensor_protos.protos.add()
spatial_pos_tensor.data_type = 2
spatial_pos_tensor.int32_data.append(ct)
txn.put('{}'.format(index).encode('ascii'),
tensor_protos.SerializeToString())
index = index + 1
total_size = total_size + len(video_data) + sys.getsizeof(
int)
print("Done writing {} clips into database with a total size of {}".format(
len(list_idx), total_size))
return total_size
import os
import sys
# Make sure that you set this to the location your caffe2 library lies.
caffe2_root = '/home/awesomebox/code/caffe2/'
sys.path.insert(0, os.path.join(caffe2_root, 'gen'))
# After setting the caffe2 root path, we will import all the caffe2 libraries needed.
from caffe2.proto import caffe2_pb2
from pycaffe2 import core, net_drawer, workspace, visualize
# net is the network definition.
net = caffe2_pb2.NetDef()
net.ParseFromString(open('inception_net.pb').read())
# tensors contain the parameter tensors.
tensors = caffe2_pb2.TensorProtos()
tensors.ParseFromString(open('inception_tensors.pb').read())
DEVICE_OPTION = caffe2_pb2.DeviceOption()
# Let's use CPU in our example.
DEVICE_OPTION.device_type = caffe2_pb2.CPU
# If you have a GPU and want to run things there, uncomment the below two lines.
# If you have multiple GPUs, you also might want to specify a gpu id.
#DEVICE_OPTION.device_type = caffe2_pb2.CUDA
#DEVICE_OPTION.cuda_gpu_id = 0
# Caffe2 has a concept of "workspace", which is similar to that of Matlab. Each workspace
# is a self-contained set of tensors and networks. In this case, we will just use the default
# workspace so we won't dive too deep into it.
workspace.SwitchWorkspace('default')
def create_data_db(dbpath, img_path, lab):
db_env = lmdb.open(dbpath, map_size=int(1024*1024*1024*30)) # size:30GB
# print(db_env.stat())
# print(dir(db_env.info()))
# with db_env.begin(write=True) as txn:
txn = db_env.begin(write=True)
# print(type(tensor_protos))
# print(dir(tensor_protos))
for k, value in enumerate(img_path):
# print("env1")
# display(db_env)
# print("env2")
# print(k)
lab_v = lab[k]
# print(k, value, lab_v)
img = cv2.imread(value, cv2.IMREAD_COLOR).astype(np.uint8)# * (1.0 / 255.0)
# print(img[0:2, 0:2].shape)
# cv2.namedWindow('img', cv2.WINDOW_AUTOSIZE)
# cv2.imshow('img', img)
# cv2.waitKey(0)
# cv2.destroyAllWindows()
img_v = cv2.resize(img, (Image_height, Image_width), interpolation = cv2.INTER_AREA)
# img_v = img_v.swapaxes(1, 2).swapaxes(0, 1)
img_v = cv2.cvtColor(img_v,cv2.COLOR_BGR2RGB)
img_obj = Image.fromarray(img_v)
img_str = StringIO.StringIO()
img_obj.save(img_str, 'PNG')
# print(img_v.shape)
# flatten_img = img_v.reshape(np.prod(img_v.shape))
# print(np.array2string(flatten_img))
# print(type(np.array2string(img_v)))
tensor_protos = caffe2_pb2.TensorProtos()
image_tensor = tensor_protos.protos.add()
# image_tensor.dims.extend(img_v.shape)
image_tensor.data_type = 4
image_tensor.string_data.append(img_str.getvalue())
img_str.close()
label_tensor = tensor_protos.protos.add()
label_tensor.data_type = 2
#=======================test=============================
# label_tensor.int32_data.append(k)
#=========================================================
label_tensor.int32_data.append(lab_v)
txn.put(
'{}'.format(k).encode('ascii'),
tensor_protos.SerializeToString()
)
# tensor_protos.Clear()
if (batch_size - 1) == (k % batch_size):
txn.commit()
print("Commit for", k)
txn = db_env.begin(write=True)
txn.commit()
db_env.close()
def create_video_db(
list_file,
output_file,
use_list=0,
use_video_id=0,
use_start_frame=0,
num_epochs=1,
):
# read csv list file
list = pandas.read_csv(list_file)
# checking necessary fields of the provided csv file
assert 'org_video' in list, \
"The input list does not have org_video column"
assert 'label' in list, \
"The input list does not have label column"
if use_video_id:
assert 'video_id' in list, \
"The input list does not have video_id column"
if use_start_frame:
assert use_list == 1, "using starting frame is recommended only " + \
"with using local file setting for feature extraction"
assert 'start_frm' in list, \
"The input list does not have start_frame column"
if num_epochs > 1:
assert use_list == 1, "using number of epochs > 1 " + \
"is recommended only with using local file setting" + \
"otherwise, there will be redundancy in data written into lmdb"
# Write to lmdb database...
LMDB_MAP_SIZE = 1 << 40 # MODIFY
env = lmdb.open(output_file, map_size=LMDB_MAP_SIZE)
# index and size counters
total_size = 0
index = 0
with env.begin(write=True) as txn:
for epoch in range(num_epochs):
# shuffle the data frame
log.info('shuffling index for epoch {}'.format(epoch))
list = list.sample(frac=1)
for _, row in list.iterrows():
file_name = row["org_video"]
label = row["label"]
if not use_list:
with open(file_name, mode='rb') as file:
video_data = file.read()
else:
video_data = file_name
tensor_protos = caffe2_pb2.TensorProtos()
video_tensor = tensor_protos.protos.add()
video_tensor.data_type = 4 # string data
video_tensor.string_data.append(str.encode(video_data))
label_tensor = tensor_protos.protos.add()
label_tensor.data_type = 2 # int32
label_tensor.int32_data.append(label)
if use_start_frame:
start_frame = row["start_frm"]
start_frame_tensor = tensor_protos.protos.add()
start_frame_tensor.data_type = 2 # int32
start_frame_tensor.int32_data.append(start_frame)
if use_video_id:
video_id = row["video_id"]
video_id_tensor = tensor_protos.protos.add()
video_id_tensor.data_type = 10 # int64
video_id_tensor.int64_data.append(video_id)
txn.put('{}'.format(index).encode('ascii'),
tensor_protos.SerializeToString())
index = index + 1
if index % 1000 == 0:
log.info('processed {} videos'.format(index))
total_size = total_size + len(video_data) + sys.getsizeof(int)
return total_size
for op in initPb.op[-8:]:
print op.output[0], op.arg[0]
if op.output[0] in ['fc8_w', 'fc8_b']:
import lmdb
from caffe2.proto import caffe2_pb2 as c2p2
env = lmdb.open('/home/filip/workbench/tree-images/workspace/lmdb/train-augmented-dataset-lmdb-227')
t = env.begin(write=False)
c = t.cursor()
c.first()
tp = c2p2.TensorProtos()
tp.ParseFromString(c.item()[1])
tp.float_data[:10]
import json
from skimage.io import imread
from os.path import join
with open('/home/filip/workbench/tree-images/feature_labels_train.json', 'r') as f:
data = json.load(f)
for _ in xrange(DATASET_SAMPLE_SIZE):
random.shuffle(data)
for num in data:
count = count + 1
if count % 100 == 0:
os.system('clear')
print GenProgressBar(count, total,
50), '%d/%d picture(s)' % (count, total)
text = str(num).zfill(DIGITS)
captcha = image.generate(text)
captcha_image = Image.open(captcha).convert('L')
img_data = np.array(captcha_image.getdata())
img_label = np.array([int(c) for c in text])
data_and_label = caffe2_pb2.TensorProtos()
data_and_label.protos.extend(
[utils.NumpyArrayToCaffe2Tensor(img_data)] + [
utils.NumpyArrayToCaffe2Tensor(img_label[i])
for i in range(DIGITS)
])
transaction.put('train_%d' % count, data_and_label.SerializeToString())
del transaction
del db
""" Report """
print 'Generated db:[' + DATABASE_NAME + '] at ' + DATABASE_PATH + '.'
def create_data_db(dbpath, img_path, lab, flag):
db_env = lmdb.open(dbpath,
map_size=int(1024 * 1024 * 1024 * 30)) # size:30GB
# db_env = lmdb.open("/tmp/ttt", map_size=int(1024*1024*1024*30)) # size:30GB
index_percent = []
# print(db_env.stat())
# print(dir(db_env.info()))
# with db_env.begin(write=True) as txn:
txn = db_env.begin(write=True)
# print(type(tensor_protos))
# print(dir(tensor_protos))
for k, value in enumerate(img_path):
# print("env1")
# display(db_env)
# print("env2")
# print(k)
lab_v = lab[k]
# print(k, value, lab_v)
img = cv2.imread(value,
cv2.IMREAD_COLOR).astype(np.uint8) # * (1.0 / 255.0)
tmp_shape = img.shape[0:2]
tmp_percent = (tmp_shape[0] * tmp_shape[1]) / (Image_width *
Image_height)
# print(img[0:2, 0:2].shape)
# cv2.namedWindow('img', cv2.WINDOW_AUTOSIZE)
# cv2.imshow('img', img)
# cv2.waitKey(0)
# cv2.destroyAllWindows()
if "up" == flag:
img_v = cv2.resize(img, (Image_height, Image_width),
interpolation=cv2.INTER_AREA)
elif "down" == flag:
tmp_img = np.ones((Image_height, Image_width,
3)) * img.mean() #.astype(np.uint8)
# print(img.shape)
tmp_xmin = int(112 - (tmp_shape[1] // 2))
# print(tmp_xmin)
tmp_ymin = int(112 - (tmp_shape[0] // 2))
# print(tmp_ymin)
tmp_img[tmp_ymin:tmp_ymin + tmp_shape[0],
tmp_xmin:tmp_xmin + tmp_shape[1]] = img
img_v = tmp_img.astype(np.uint8)
# print(img.mean())
# print(tmp_img.mean())
# print(tmp_img[112,112])
# img_v = img_v.swapaxes(1, 2).swapaxes(0, 1)
img_v = cv2.cvtColor(img_v, cv2.COLOR_BGR2RGB)
# print(type(img_v))
# print(img_v.dtype)
# print(img_v.shape)
# exit(0)
img_obj = Image.fromarray(img_v)
img_str = StringIO.StringIO()
img_obj.save(img_str, 'PNG')
# print(img_v.shape)
# flatten_img = img_v.reshape(np.prod(img_v.shape))
# print(np.array2string(flatten_img))
# print(type(np.array2string(img_v)))
tensor_protos = caffe2_pb2.TensorProtos()
image_tensor = tensor_protos.protos.add()
# image_tensor.dims.extend(img_v.shape)
image_tensor.data_type = 4
image_tensor.string_data.append(img_str.getvalue())
img_str.close()
label_tensor = tensor_protos.protos.add()
label_tensor.data_type = 2
#=======================test=============================
# label_tensor.int32_data.append(k)
#=========================================================
label_tensor.int32_data.append(lab_v)
index_percent.append((value, k, tmp_percent, lab_v))
txn.put('{}'.format(k).encode('ascii'),
tensor_protos.SerializeToString())
# tensor_protos.Clear()
if (batch_size - 1) == (k % batch_size):
txn.commit()
print("Commit for", k)
txn = db_env.begin(write=True)
txn.commit()
db_env.close()
return index_percent
def TranslateModel(
cls,
caffe_net,
pretrained_net,
is_test=False,
input_mean=None,
net_state=None,
):
net_state = caffe_pb2.NetState() if net_state is None else net_state
net = caffe2_pb2.NetDef()
net.name = caffe_net.name
net_params = caffe2_pb2.TensorProtos()
if len(caffe_net.layer) == 0:
raise ValueError(
'I think something is wrong. This translation script '
'only accepts new style layers that are stored in the '
'layer field.')
if input_mean:
caffenet_mean = caffe_pb2.BlobProto()
caffenet_mean.ParseFromString(open(input_mean, 'rb').read())
mean_ = utils.CaffeBlobToNumpyArray(caffenet_mean)
mean_tensor = utils.NumpyArrayToCaffe2Tensor(mean_, 'mean_')
net_params.protos.extend([mean_tensor])
mean_op = caffe2_pb2.OperatorDef()
mean_op.type = 'Sub'
mean_op.input.extend(['data_', 'mean_'])
# Assume that input blob's name is "data"
mean_op.output.extend(['data'])
net.op.extend([mean_op])
i = 0
while i < len(caffe_net.layer):
if not _ShouldInclude(net_state, caffe_net.layer[i]):
log.info('Current net state does not need layer {}'.format(
caffe_net.layer[i].name))
continue
log.info('Translate layer {}'.format(caffe_net.layer[i].name))
# Get pretrained one
pretrained_layers_index = ([
l for l in xrange(len(pretrained_net.layer))
if pretrained_net.layer[l].name == caffe_net.layer[i].name
] + [
l for l in xrange(len(pretrained_net.layers))
if pretrained_net.layers[l].name == caffe_net.layer[i].name
])
is_bn = False
if len(pretrained_layers_index) > 1:
raise ValueError(
'huh? more than one pretrained layer of one name?')
elif len(pretrained_layers_index) == 1:
if pretrained_net.layer[
pretrained_layers_index[0]].type == "BatchNorm":
# A Scale layer should follow BatchNorm layer
# according to paper https://arxiv.org/abs/1502.03167.
assert pretrained_net.layer[pretrained_layers_index[0] +
1].type == "Scale"
pretrained_blobs = [utils.CaffeBlobToNumpyArray(blob)
for blob in pretrained_net.layer[pretrained_layers_index[0]].blobs] + \
[utils.CaffeBlobToNumpyArray(blob)
for blob in pretrained_net.layer[pretrained_layers_index[0] + 1].blobs]
is_bn = True
else:
pretrained_blobs = [
utils.CaffeBlobToNumpyArray(blob) for blob in
pretrained_net.layer[pretrained_layers_index[0]].blobs
]
else:
# No pretrained layer for the given layer name. We'll just pass
# no parameter blobs.
# print 'No pretrained layer for layer', layer.name
pretrained_blobs = []
operators, params = cls.TranslateLayer(caffe_net.layer[i],
pretrained_blobs, is_test)
net.op.extend(operators)
net_params.protos.extend(params)
if is_bn:
i += 2
else:
i += 1
return net, net_params
pyplot.title("Training data distribution, feature 0 and 1")
for i in range(3):
pyplot.plot(train_features[train_labels == i, 0],
train_features[train_labels == i, 1], legend[i])
pyplot.figure()
pyplot.title("Testing data distribution, feature 0 and 1")
for i in range(3):
pyplot.plot(test_features[test_labels == i, 0],
test_features[test_labels == i, 1], legend[i])
# Now, as promised, let's put things into a Caffe2 DB. In this DB, what would happen is that we will use "train_xxx" as the key, and use a TensorProtos object to store two tensors for each data point: one as the feature and one as the label. We will use Caffe2 python's DB interface to do so.
# In[6]:
# First, let's see how one can construct a TensorProtos protocol buffer from numpy arrays.
feature_and_label = caffe2_pb2.TensorProtos()
feature_and_label.protos.extend([
utils.NumpyArrayToCaffe2Tensor(features[0]),
utils.NumpyArrayToCaffe2Tensor(labels[0])
])
print('This is what the tensor proto looks like for a feature and its label:')
print(str(feature_and_label))
print('This is the compact string that gets written into the db:')
print(feature_and_label.SerializeToString())
# In[7]:
# Now, actually write the db.
def write_db(db_type, db_name, features, labels):
def TranslateModel(cls,
caffe_net,
pretrained_net,
is_test=False,
net_state=None,
remove_legacy_pad=False,
input_dims=None):
net_state = caffe_pb2.NetState() if net_state is None else net_state
net = caffe2_pb2.NetDef()
net.name = caffe_net.name
net_params = caffe2_pb2.TensorProtos()
if len(caffe_net.layers) > 0:
raise ValueError(
'I think something is wrong. This translation script '
'only accepts new style layers that are stored in the '
'layer field.')
if not input_dims:
input_dims = _GetInputDims(caffe_net)
for layer in caffe_net.layer:
if not _ShouldInclude(net_state, layer):
log.info('Current net state does not need layer {}'.format(
layer.name))
continue
log.info('Translate layer {}'.format(layer.name))
# Get pretrained one
pretrained_layers = (
[l for l in pretrained_net.layer if l.name == layer.name] +
[l for l in pretrained_net.layers if l.name == layer.name])
if len(pretrained_layers) > 1:
print('>>> huh? more than one pretrained layer of one name?')
print(
'>>> Assuming these layers have no trainable parameters (e.g relu or pooling)'
)
print([(pt.name, pt.type) for pt in pretrained_layers])
pt_types = [pt.type for pt in pretrained_layers]
if len(set(pt_types)) == len(pt_types):
print(
'>>> But, just in case, try to match layer types since types are unique. If not, do not transfer params.'
)
for pt in pretrained_layers:
if pt.type == layer.type:
print ' Found matching type {}'.format(layer.type)
print ' Setting pretrained blobs'
pretrained_blobs = [
utils.CaffeBlobToNumpyArray(blob)
for blob in pt.blobs
]
#print pretrained_blobs
else:
print('>>> Setting pretrained blobs = []')
pretrained_blobs = []
#raise ValueError(
# 'huh? more than one pretrained layer of one name?')
elif len(pretrained_layers) == 1:
pretrained_blobs = [
utils.CaffeBlobToNumpyArray(blob)
for blob in pretrained_layers[0].blobs
]
else:
# No pretrained layer for the given layer name. We'll just pass
# no parameter blobs.
# print 'No pretrained layer for layer', layer.name
pretrained_blobs = []
operators, params = cls.TranslateLayer(layer,
pretrained_blobs,
is_test,
net=net,
net_params=net_params,
input_dims=input_dims)
net.op.extend(operators)
net_params.protos.extend(params)
if remove_legacy_pad:
assert input_dims, \
'Please specify input_dims to remove legacy_pad'
net = _RemoveLegacyPad(net, net_params, input_dims)
return net, net_params
