def main(args_list):
args = parse_args(args_list)
print('Called with args:')
print(args)
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
cfg.GPU_ID = args.GPU_ID
print('Using config:')
pprint.pprint(cfg)
if not args.randomize:
# fix the random seeds (numpy and caffe) for reproducibility
np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
print 'Setting GPU device %d for training' % cfg.GPU_ID
caffe.set_mode_gpu()
caffe.set_device(cfg.GPU_ID)
imdb, roidb = combined_roidb(args.imdb_name)
print '{:d} roidb entries'.format(len(roidb))
output_dir = get_output_dir(imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
train_net(args.solver, roidb, output_dir,
pretrained_model=args.pretrained_model,
max_iters=args.max_iters)
def _init_caffe(cfg):
np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
caffe.set_mode_gpu()
caffe.set_device(cfg.GPU_ID)
def _init_caffe(cfg):
"""Initialize pycaffe in a training process.
"""
import caffe
# fix the random seeds (numpy and caffe) for reproducibility
np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
# set up caffe
caffe.set_mode_gpu()
caffe.set_device(cfg.GPU_ID)
def _init_caffe(cfg):
"""Initialize pycaffe in a training process.
"""
import caffe
# fix the random seeds (numpy and caffe) for reproducibility
np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
# set up caffe
caffe.set_mode_gpu()
caffe.set_device(cfg.GPU_ID)
def run(self):
"""This method runs in the new process."""
if self.device >= 0:
os.environ['CUDA_VISIBLE_DEVICES'] = str(self.device)
import caffe
if self.device >= 0:
caffe.set_mode_gpu()
else:
caffe.set_mode_cpu()
caffe.set_random_seed(0)
np.random.seed(0)
self.model = CaffeModel(*self.model_info)
self.model.img = np.zeros((3, 1, 1), dtype=np.float32)
while True:
req = self.req_q.get()
layers = []
if isinstance(req, FeatureMapRequest):
for layer in reversed(self.model.layers()):
if layer in req.layers:
layers.append(layer)
features = self.model.eval_features_tile(req.img.array, layers)
req.img.unlink()
features_shm = {
layer: SharedNDArray.copy(features[layer])
for layer in features
}
self.resp_q.put(FeatureMapResponse(req.resp, features_shm))
if isinstance(req, SCGradRequest):
for layer in reversed(self.model.layers()):
if layer in req.content_layers + req.style_layers + req.dd_layers:
layers.append(layer)
self.model.roll(req.roll, jitter_scale=1)
loss, grad = self.model.eval_sc_grad_tile(
req.img.array, req.start, layers, req.content_layers,
req.style_layers, req.dd_layers, req.content_weight,
req.style_weight, req.dd_weight)
req.img.unlink()
self.model.roll(-req.roll, jitter_scale=1)
self.resp_q.put(
SCGradResponse(req.resp, loss, SharedNDArray.copy(grad)))
if isinstance(req, SetFeaturesAndGrams):
self.model.features = \
{layer: req.features[layer].array.copy() for layer in req.features}
self.model.grams = \
{layer: req.grams[layer].array.copy() for layer in req.grams}
self.resp_q.put(())
def roi_generate(queue=None,
imdb_name=None,
roi_conv_model_path=None,
cfg=None,
test_prototxt=None,
overwrite=None):
"""Use a trained RPN to generate proposals.
"""
output_dir = './output/'
net_name = os.path.splitext(os.path.basename(roi_conv_model_path))[0]
output_path_name = os.path.join(output_dir, net_name)
queue.put({'proposal_path': output_path_name})
if not os.path.exists(output_path_name):
os.makedirs(output_path_name)
elif overwrite:
shutil.rmtree(output_path_name)
os.makedirs(output_path_name)
else:
return
print 'RPN model: {}'.format(roi_conv_model_path)
print('Using config:')
pprint.pprint(cfg)
# fix the random seeds (numpy and caffe) for reproducibility
import caffe
np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
# set up caffe
caffe.set_mode_gpu()
caffe.set_device(cfg.GPU_ID)
# NOTE: the matlab implementation computes proposals on flipped images, too.
# We compute them on the image once and then flip the already computed
# proposals. This might cause a minor loss in mAP (less proposal jittering).
from datasets.factory import get_imdb
imdb = get_imdb(imdb_name)
print 'Loaded dataset `{:s}` for bbox generation'.format(imdb.name)
# Load RPN and configure output directory
roi_net = caffe.Net(test_prototxt, roi_conv_model_path, caffe.TEST)
roi_net.name = net_name
print 'Output will be saved to `{:s}`'.format(output_path_name)
print 'roinet.name: ', roi_net.name
# Generate proposals on the imdb
roi_proposals = imdb_proposals(roi_net, imdb, output_path_name)
def train(args):
'''train lnet using data prepare by `prepare()`
'''
def get_data_size(txt):
size = 0
with open(txt, 'r') as fin:
for line in fin.readlines():
line = line.strip()
data = h5py.File(line, 'r')
size += data['target'].shape[0]
data.close()
return size
# init caffe
np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
if cfg.GPU_ID < 0:
caffe.set_mode_cpu()
else:
caffe.set_mode_gpu()
caffe.set_device(cfg.GPU_ID)
# solver parameter setup
batch_size = 128
train_size = get_data_size('data/lnet_train.txt')
val_size = get_data_size('data/lnet_val.txt')
iter_train = train_size / batch_size
iter_test = val_size / batch_size
max_iter = args.epoch * iter_train
final_model = 'tmp/lnet_iter_%d.caffemodel' % max_iter
solver_param = caffe_pb2.SolverParameter()
with open('proto/l_solver.prototxt', 'r') as fin:
text_format.Merge(fin.read(), solver_param)
solver_param.max_iter = max_iter
solver_param.snapshot = iter_train
solver_param.test_interval = iter_train
solver_param.test_iter[0] = iter_test
solver_param.base_lr = args.lr
solver_param.gamma = args.lrw
solver_param.stepsize = args.lrp * iter_train
tmp_solver_prototxt = 'tmp/l_solver.prototxt'
with open(tmp_solver_prototxt, 'w') as fout:
fout.write(text_format.MessageToString(solver_param))
# solver setup
solver = caffe.SGDSolver(tmp_solver_prototxt)
# train
solver.solve(args.snapshot)
shutil.copyfile(final_model, 'model/l.caffemodel')
def rpn_generate_signle_gpu(rank):
cfg.GPU_ID=gpus[rank]
print('Using config:')
pprint.pprint(cfg)
import caffe
np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
# set up caffe
caffe.set_mode_gpu()
caffe.set_device(cfg.GPU_ID)
# Load RPN and configure output directory
rpn_net = caffe.Net(rpn_test_prototxt, rpn_model_path, caffe.TEST)
# Generate proposals on the imdb
rpn_proposals = imdb_proposals(rpn_net, imdb, rank, len(gpus), output_dir)
def init_detection_net(self, gpu_id=0, prototxt=None, caffemodel=None):
"""init extraction network"""
cfg.TEST.HAS_RPN = True # Use RPN for proposals
if prototxt is None:
prototxt = os.path.join(cfg.ROOT_DIR, 'models', NETS['zf'][0],
'faster_rcnn_alt_opt', 'faster_rcnn_test.pt')
if caffemodel is None:
caffemodel = os.path.join(cfg.ROOT_DIR, 'output/default/train',
NETS['zf'][1])
if not os.path.isfile(caffemodel):
raise IOError(('{:s} not found.\nDid you run ./data/script/'
'fetch_faster_rcnn_models.sh?').format(caffemodel))
#np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
caffe.set_mode_gpu()
caffe.set_device(gpu_id)
self.net_d = caffe.Net(prototxt, caffemodel, caffe.TEST)
def main(args):
"""TODO: Docstring for main.
"""
# Fix random seeds (numpy and caffe) for reproducibility
logger.info('Initializing caffe..')
np.random.seed(RANDOM_SEED)
caffe.set_random_seed(RANDOM_SEED)
if GPU_ONLY:
caffe.set_mode_gpu()
caffe.set_device(int(args['gpu_id']))
else:
caffe.set_mode_cpu()
logger.info('Loading training data')
# Load imagenet training images and annotations
imagenet_folder = os.path.join(args['imagenet'], 'images')
imagenet_annotations_folder = os.path.join(args['imagenet'], 'gt')
objLoaderImgNet = loader_imagenet(imagenet_folder,
imagenet_annotations_folder, logger)
train_imagenet_images = objLoaderImgNet.loaderImageNetDet()
# Load alov training images and annotations
alov_folder = os.path.join(args['alov'], 'images')
alov_annotations_folder = os.path.join(args['alov'], 'gt')
objLoaderAlov = loader_alov(alov_folder, alov_annotations_folder, logger)
objLoaderAlov.loaderAlov()
train_alov_videos = objLoaderAlov.get_videos()
# create example generator and setup the network
objExampleGen = example_generator(float(args['lamda_shift']),
float(args['lamda_scale']),
float(args['min_scale']),
float(args['max_scale']), logger)
objRegTrain = regressor_train(args['train_prototxt'],
args['init_caffemodel'], int(args['gpu_id']),
args['solver_prototxt'], logger)
objTrackTrainer = tracker_trainer(objExampleGen, objRegTrain, logger)
while objTrackTrainer.num_batches_ < kNumBatches:
train_image(objLoaderImgNet, train_imagenet_images, objTrackTrainer)
train_video(train_alov_videos, objTrackTrainer)
def check_gradient_single(self,
layer,
bottom,
top,
check_bottom='all',
top_id=0,
top_data_id=0):
""""""
# Retrieve Blobs to check
propagate_down = [False for i in xrange(len(bottom))]
blobs_to_check = []
for blob in layer.blobs:
blobs_to_check += [blob]
if check_bottom == 'all':
check_bottom = range(len(bottom))
assert len(check_bottom) <= len(bottom)
for cb in check_bottom:
blobs_to_check += [bottom[cb]]
propagate_down[cb] = True
# Compute the gradient analytically using Backward
caffe.set_random_seed(self.seed_)
layer.Reshape(bottom, top)
layer.Forward(bottom, top)
self.get_obj_and_gradient(layer, top, top_id, top_data_id)
layer.Backward(top, propagate_down, bottom)
# Store computed diff
ana_grads = [b.diff.copy() for b in blobs_to_check]
# Compute finite diff
for bi, (ana_grad, blob) in enumerate(zip(ana_grads, blobs_to_check)):
for fi in xrange(blob.count):
step = self.stepsize_
# L(fi <-- fi+step)
blob.data.flat[fi] += step
caffe.set_random_seed(self.seed_)
layer.Reshape(bottom, top)
layer.Forward(bottom, top)
ploss = self.get_obj_and_gradient(layer, top, top_id,
top_data_id)
# L(fi <-- fi-step)
blob.data.flat[fi] -= 2 * step
caffe.set_random_seed(self.seed_)
layer.Reshape(bottom, top)
layer.Forward(bottom, top)
nloss = self.get_obj_and_gradient(layer, top, top_id,
top_data_id)
grad = (ploss - nloss) / (2. * step)
agrad = ana_grad.flat[fi]
feat = blob.data.flat[fi]
if self.kink_ - self.kink_range_ > np.abs(feat) \
or np.abs(feat) > self.kink_ + self.kink_range_:
scale = max(max(np.abs(agrad), np.abs(grad)), 1.0)
assert np.isclose(
agrad, grad, rtol=0, atol=self.threshold_ *
scale), ("(top_id, top_data_id, blob_id, feat_id)"
"=(%d, %d, %d, %d); feat=%g; "
"objective+ = %g; objective- = %g; "
"analitical_grad=%g; finite_grad=%g" %
(top_id, top_data_id, bi, fi, feat, ploss,
nloss, agrad, grad))
def __init__(self,
weights_path,
image_net_proto,
lstm_net_proto,
vocab_path,
device_id=-1):
if device_id >= 0:
caffe.set_mode_gpu()
caffe.set_device(device_id)
else:
caffe.set_mode_cpu()
caffe.set_random_seed(0)
# Setup image processing net.
phase = caffe.TEST
self.image_net = caffe.Net(image_net_proto, weights_path, phase)
image_data_shape = self.image_net.blobs['data'].data.shape
self.transformer = caffe.io.Transformer({'data': image_data_shape})
channel_mean = np.zeros(image_data_shape[1:])
channel_mean_values = [104, 117, 123]
assert channel_mean.shape[0] == len(channel_mean_values)
for channel_index, mean_val in enumerate(channel_mean_values):
channel_mean[channel_index, ...] = mean_val
self.transformer.set_mean('data', channel_mean)
self.transformer.set_channel_swap('data', (2, 1, 0))
self.transformer.set_transpose('data', (2, 0, 1))
# Setup sentence prediction net.
self.lstm_net = caffe.Net(lstm_net_proto, weights_path, phase)
self.vocab = ['<EOS>']
with open(vocab_path, 'r') as vocab_file:
self.vocab += [word.strip() for word in vocab_file.readlines()]
net_vocab_size = self.lstm_net.blobs['predict'].data.shape[2]
if len(self.vocab) != net_vocab_size:
raise Exception('Invalid vocab file: contains %d words; '
'net expects vocab with %d words' %
(len(self.vocab), net_vocab_size))
def _run(self, cnndata, gpu=None):
if gpu is not None:
os.environ['CUDA_VISIBLE_DEVICES'] = str(gpu)
import caffe
caffe.set_random_seed(0)
self.net = caffe.Net(str(cnndata.deploy), 1, weights=str(cnndata.model))
self.data = dd._LayerIndexer(self.net, 'data')
self.diff = dd._LayerIndexer(self.net, 'diff')
if gpu is not None:
caffe.set_mode_gpu()
else:
caffe.set_mode_cpu()
while True:
req = self.req_q.get()
if req.cleanup:
for blob in self.net.blobs:
self.diff[blob] = 0
grad = self._grad_single_tile(req.data, req.layers)
resp = TileResponse(req.resp, grad)
self.resp_q.put(resp)
self.req_q.task_done()
def main(args_list):
args = parse_args(args_list)
print('Called with args:')
print(args)
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
cfg.GPU_ID = args.GPU_ID
print('Using config:')
pprint.pprint(cfg)
if not args.randomize:
# fix the random seeds (numpy and caffe) for reproducibility
np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
print 'Setting GPU device %d for training' % cfg.GPU_ID
caffe.set_mode_gpu()
caffe.set_device(cfg.GPU_ID)
imdb, roidb = combined_roidb(args.imdb_name)
print '{:d} roidb entries'.format(len(roidb))
output_dir = get_output_dir(imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
train_net(args.solver,
roidb,
output_dir,
pretrained_model=args.pretrained_model,
max_iters=args.max_iters)
def solve(proto, roidb, pretrained_model, gpus, uid, rank, output_dir,
max_iter):
caffe.set_random_seed(cfg.RNG_SEED)
caffe.set_mode_gpu()
caffe.set_device(gpus[rank])
caffe.set_solver_count(len(gpus))
caffe.set_solver_rank(rank)
caffe.set_multiprocess(True)
cfg.GPU_ID = gpus[rank]
solverW = SolverWrapper(proto, roidb, output_dir, rank, pretrained_model)
solver = solverW.getSolver()
nccl = caffe.NCCL(solver, uid)
nccl.bcast()
solver.add_callback(nccl)
if solver.param.layer_wise_reduce:
solver.net.after_backward(nccl)
count = 0
while count < max_iter:
solver.step(cfg.TRAIN.SNAPSHOT_ITERS)
if rank == 0:
solverW.snapshot()
count = count + cfg.TRAIN.SNAPSHOT_ITERS
#renderContext = {}
#jinjiaEnv = jinja2.Environment(loader = jinja2.FileSystemLoader('./')).get_template('template.html')
savedNet = sys.argv[1]
predictDataset = sys.argv[2]
outtag = sys.argv[3]
gpuid = int(sys.argv[4])
resultfolder, modelfile = os.path.split(savedNet)
outputFolder = resultfolder + r'/test_{}'.format(outtag)
if(os.path.exists(outputFolder) == False):
os.makedirs(outputFolder)
caffe.set_random_seed(23333)
caffe.set_mode_gpu()
caffe.set_device(gpuid)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
fh = logging.FileHandler(outputFolder + '/test_log_text.log')
fh.setLevel(logging.DEBUG)
ch = logging.StreamHandler()
ch.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s: %(message)s')
ch.setFormatter(formatter)
fh.setFormatter(formatter)
logger.addHandler(ch)
logger.addHandler(fh)
def worker(rank, uid, gpus, solver_prototxt, roidb, pretrained_model, max_iter,
output_dir):
"""
Training worker
:param rank: The process rank
:param uid: The caffe NCCL uid
:param solver_proto: Solver prototxt
:param roidb: Training roidb
:param pretrained_model: Pretrained model
:param gpus: GPUs to be used for training
:param max_iter: Maximum number of training iterations
:param output_dir: Output directory used for saving models
:return:
"""
# Setup caffe
cfg.RANK = rank
cfg.GPU_ID = gpus[rank] # Will be used in gpu_nms
caffe.set_device(cfg.GPU_ID)
caffe.set_random_seed(cfg.RNG_SEED + rank)
caffe.set_mode_gpu()
caffe.set_solver_count(len(gpus))
caffe.set_solver_rank(rank)
caffe.set_multiprocess(True)
# Setup Solver
solverW = SolverWrapper(
solver_prototxt=str(solver_prototxt),
roidb=roidb,
output_dir=str(output_dir),
rank=rank,
pretrained_model=str(pretrained_model))
solver = solverW.get_solver()
nccl = caffe.NCCL(solver, uid)
nccl.bcast()
solver.add_callback(nccl)
if solver.param.layer_wise_reduce:
solver.net.after_backward(nccl)
# Train the model for the specified number of iterations
target_layers = filter(lambda x: x.startswith('target_layer'),
solver.net.layer_dict.keys())
if rank == 0:
t = Timer()
while solver.iter < max_iter:
for n in target_layers:
solver.net.layer_dict[n].set_iter(solver.iter)
if rank == 0:
t.tic()
solver.step(1)
if (solver.iter % cfg.TRAIN.SNAPSHOT == 0
or solver.iter == max_iter) and rank == 0:
# Snapshot only in the main process
solverW.snapshot(solver.iter == max_iter)
if rank == 0:
t.toc()
eta_in_s = int((max_iter - solver.iter) * t.average_time)
try:
for loss_name, loss_val in solver.net.blobs.items():
if 'loss' not in loss_name:
continue
tb.sess.add_scalar_value(
loss_name, float(loss_val.data), step=solver.iter)
for n in target_layers:
tb.sess.add_scalar_value(
n + '_accuracy',
float(solver.net.layer_dict[n].accuracy),
step=solver.iter)
tb.sess.add_scalar_value(
"speed", 1. / t.average_time, step=solver.iter)
tb.sess.add_scalar_value(
"ETA (min)", eta_in_s / 60., step=solver.iter)
except:
logger.warning('Failed to submit data to Tensorboard')
sys.stdout.write('\r{}, Speed: {:5f} iter/sec, ETA: {:8s}'.format(
', '.join([
'{}: {:5f}'.format(i[0], i[1].data)
for i in solver.net.blobs.items() if 'loss' in i[0]
] + [
'{}: {:5f}'.format(
n +
'_accuracy', float(solver.net.layer_dict[n].accuracy))
for n in target_layers
]), 1. / t.average_time,
str(datetime.timedelta(seconds=eta_in_s))))
sys.stdout.flush()
#!/usr/bin/env python
import _init_paths
import caffe
import numpy as np
import os.path as osp
from pprint import pprint
caffe.set_mode_cpu()
caffe.set_random_seed(13397)
np.random.seed(0)
net = caffe.Net('TensorStuff.prototxt', caffe.TRAIN)
print("blobs {}\nparams {}".format(net.blobs.keys(), net.params.keys()))
N = net.blobs['input_data'].num
assert net.blobs['gt_viewpoint'].data.shape == (N, 3)
net.blobs['input_data'].data[...] = np.random.rand(
*net.blobs['input_data'].data.shape)
net.blobs['gt_viewpoint'].data[...] = np.random.uniform(-np.pi, np.pi, (N, 3))
net.params['scale_fc_viewpoint_3x2'][0].data[...] = np.array([1., 2, 3])
out = net.forward()
assert np.allclose(net.blobs['fc_viewpoint_6'].data.reshape(4, 3, 2),
net.blobs['fc_viewpoint_3x2'].data)
assert np.allclose(
net.blobs['fc_viewpoint_3x2'].data * np.array([1., 2, 3]).reshape(1, 3, 1),
net.blobs['fc_viewpoint_3x2_by_T'].data)
parser.add_argument('-i','--input',type=str,required=True,help="Input .types file to predict")
parser.add_argument('-g','--gpu',type=int,help='Specify GPU to run on',default=-1)
parser.add_argument('-o','--output',type=str,help='Output file name',default=None)
parser.add_argument('-s','--seed',type=int,help='Random seed',default=None)
parser.add_argument('-k','--keep',action='store_true',default=False,help="Don't delete prototxt files")
parser.add_argument('--rotations',type=int,help='Number of rotations; rotatation must be enabled in test net!',default=1)
parser.add_argument('--max_score',action='store_true',default=False,help="take max score per ligand as its score")
parser.add_argument('--max_affinity',action='store_true',default=False,help="take max affinity per ligand as its score")
parser.add_argument('--notcalc_predictions', type=str, default='',help='use file of predictions instead of calculating')
return parser.parse_args(argv)
if __name__ == '__main__':
args = parse_args()
if not args.output:
out = sys.stdout
else:
out = open(args.output, 'w')
if args.seed != None:
caffe.set_random_seed(args.seed)
if not args.notcalc_predictions:
predictions = predict_lines(args)
else:
with open(args.notcalc_predictions, 'r') as f:
predictions = f.readlines()
if args.max_score or args.max_affinity:
predictions = maxLigandScore(predictions, args.max_affinity)
out.writelines(predictions)
print(args)
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
train_cfg.GPU_ID = args.gpu_id
print('Using config:')
pprint.pprint(train_cfg)
if not args.randomize:
# fix the random seeds (numpy and caffe) for reproducibility
np.random.seed(train_cfg.RNG_SEED)
caffe.set_random_seed(train_cfg.RNG_SEED)
# set up caffe
caffe.set_mode_gpu()
caffe.set_device(args.gpu_id)
print 'imdb name `{:s}`'.format(args.imdb_name)
imdb, roidb = combined_roidb(args.imdb_name)
print '{:d} roidb entries'.format(len(roidb))
output_dir = get_output_dir(imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
train_net(args.solver, roidb, output_dir,
pretrained_model=args.pretrained_model,
max_iters=args.max_iters)
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import matplotlib.image as mpimg
# import helper_functions
import timeit
import lmdb
from caffe.proto import caffe_pb2
import cv2
from google.protobuf import text_format
import operator
from PIL import Image
#Initialise Caffe using GPU
caffe.set_device(0)
caffe.set_mode_gpu()
caffe.set_random_seed(0)
np.random.seed(0)
print('Initialized Caffe!')
#network_path = '/home/d/Desktop/model_compare_caffe/svhn/simple/3fcc_sigmoid_model_svhn.prototxt';
network_path = '/home/d/Desktop/model_compare_caffe/svhn/simple/svhn_simple.prototxt';
weight_path = '/home/d/Desktop/model_compare_caffe/svhn/simple/svhn_simple.caffemodel'
net = caffe.Net(network_path, weight_path, caffe.TEST) # caffe.TEST for testing
width = 32
height = 32
min_range = 0
max_range = 26000
data = '/home/d/Desktop/model_compare_caffe/svhn/svhn_test_images/'
result = '/home/d/Desktop/model_compare_caffe/svhn/svhn_test_images.txt'
print('Called with args:')
print(args)
# ================ init
# set conf
if args.cfg_file is not None:
rpn_config.cfg_from_file(args.cfg_file)
print('RPN using config:')
pprint.pprint(rpn_config.cfg)
# set up caffe
if not args.randomize:
# fix the random seeds (numpy and caffe) for reproducibility
np.random.seed(rpn_config.cfg.RNG_SEED)
caffe.set_random_seed(rpn_config.cfg.RNG_SEED)
if args.cpu_mode:
caffe.set_mode_cpu()
else:
caffe.set_mode_gpu()
caffe.set_device(args.gpu_id)
# ============== stage-pre
print 'start stage-pre...'
if not os.path.exists(args.test_def):
raise IOError(('{:s} not found!').format(args.test_def))
# calculate ouput size map and prepare anchors
output_w, output_h = rpn_train.proposal_calc_output_size(args.imdb_name,
args.test_def)
formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s: %(message)s')
ch.setFormatter(formatter)
fh.setFormatter(formatter)
logger.addHandler(ch)
logger.addHandler(fh)
logger.info('outfolder = {}'.format(outfolder))
print(configFilePath)
params = loadParams(configFilePath)
random.seed(params['randomSeed'])
np.random.seed(params['randomSeed'])
logger.info('Setting Seed...')
caffe.set_random_seed(params['randomSeed'])
caffe.set_mode_gpu()
logger.info('Setting GPU...')
caffe.set_device(gpuid)
logger.info('Done.')
logger.info('Loading network and solver settings...')
BRDFNet = groove_network()
BRDFNet.createNet(params['batchSize'], 0, params['BN'], params['NormalizeInput'])
BRDFNet.saveNet(outfolder)
import numpy as np
from pprint import pprint
from sys import exit
from PIL import Image
from os import path
import caffe, cv2
caffe.set_random_seed(666)
import numpy.random
numpy.random.seed(666)
import random
random.seed(666)
cv2.setRNGSeed(666)
import util
class RpnDetector:
def __init__(self, configFile):
root = path.dirname(configFile)
self.config = util.readConfig(configFile)
caffe.set_device(0)
caffe.set_mode_gpu()
self.net = caffe.Net(
path.join(root, self.config["dnn_deploy_file"][0]),
path.join(
root,
self.config["dnn_weight_files"][0],
), caffe.TEST)
imdb = get_imdb(imdb_names)
return imdb, roidb
if __name__ == '__main__':
if CFG_FILE is not None:
cfg_from_file(CFG_FILE)
if SET_CFGS is not None:
cfg_from_list(SET_CFGS)
print('Using config:')
pprint.pprint(cfg)
if not RANDOMIZE:
# fix the random seeds (numpy and caffe) for reproducibility
np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
# set up caffe
caffe.set_mode_cpu()
imdb, roidb = combined_roidb(IMDB_NAME)
print '{:d} roidb entries'.format(len(roidb))
output_dir = get_output_dir(imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
# train_net(SOLVER, roidb, output_dir,
# pretrained_model=PRETRAINED_WEIGHTS,
# max_iters=MAX_ITERS)
def main(argv):
args = parse_args(argv)
if args.wandb:
wandb.init(project='gentrain', config=args)
if args.out_prefix == '':
try:
os.mkdir('wandb_output')
except FileExistsError:
pass
args.out_prefix = 'wandb_output/' + wandb.run.id
sys.stderr.write("Setting output prefix to %s\n" % args.out_prefix)
config = open('%s.config' % args.out_prefix, 'wt')
config.write('\n'.join(map(lambda kv: '%s : %s' % kv, vars(args).items())))
config.close()
# read solver and model param files and set general params
# batch size is set through string replacement because
data_str = open(args.data_model_file).read()
data_str = data_str.replace('BATCH_SIZE', str(args.batch_size))
data_param = NetParameter.from_prototxt_str(data_str)
gen_str = open(args.gen_model_file).read()
gen_str = gen_str.replace('BATCH_SIZE', str(args.batch_size))
gen_param = NetParameter.from_prototxt_str(gen_str)
disc_str = open(args.disc_model_file).read()
disc_str = disc_str.replace('BATCH_SIZE', str(args.batch_size))
disc_param = NetParameter.from_prototxt_str(disc_str)
gen_param.force_backward = True
disc_param.force_backward = True
if args.solver_file:
solver_param = SolverParameter.from_prototxt(args.solver_file)
else:
solver_param = SolverParameter()
solver_param.max_iter = args.max_iter
solver_param.test_interval = args.max_iter + 1
solver_param.random_seed = args.random_seed
caffe.set_random_seed(args.random_seed) #this should be redundant
#check for cmdline overrides
if args.solver is not None:
solver_param.type = args.solver
if args.clip_gradients is not None:
solver_param.clip_gradients = args.clip_gradients
if args.momentum is not None:
solver_param.momentum = args.momentum
if args.momentum2 is not None:
solver_param.momentum2 = args.momentum2
if args.lr_policy is not None:
solver_param.lr_policy = args.lr_policy
if args.base_lr is not None:
solver_param.base_lr = args.base_lr
if args.weight_decay is not None:
solver_param.weight_decay = args.weight_decay
for fold, train_file, test_file in get_train_and_test_files(
args.data_prefix, args.fold_nums):
# create nets for producing train and test data
print('Creating train data net')
data_param.set_molgrid_data_source(train_file, args.data_root)
train_data = Net.from_param(data_param, phase=caffe.TRAIN)
print('Creating test data net')
test_data = {}
data_param.set_molgrid_data_source(train_file, args.data_root)
test_data['train'] = Net.from_param(data_param, phase=caffe.TEST)
if test_file != train_file:
data_param.set_molgrid_data_source(test_file, args.data_root)
test_data['test'] = Net.from_param(data_param, phase=caffe.TEST)
# create solver for training generator net
print('Creating generator solver')
gen_prefix = '{}_{}_gen'.format(args.out_prefix, fold)
gen = Solver.from_param(solver_param,
net_param=gen_param,
snapshot_prefix=gen_prefix)
if args.gen_weights_file:
gen.net.copy_from(args.gen_weights_file)
if 'lig_gauss_conv' in gen.net.blobs:
gen.net.copy_from('lig_gauss_conv.caffemodel')
# create solver for training discriminator net
print('Creating discriminator solver')
disc_prefix = '{}_{}_disc'.format(args.out_prefix, fold)
disc = Solver.from_param(solver_param,
net_param=disc_param,
snapshot_prefix=disc_prefix)
if args.disc_weights_file:
disc.net.copy_from(args.disc_weights_file)
# continue previous training state, or start new training output file
loss_file = '{}_{}.training_output'.format(args.out_prefix, fold)
print('loss file', loss_file)
if args.cont_iter:
gen.restore('{}_iter_{}.solverstate'.format(
gen_prefix, args.cont_iter))
disc.restore('{}_iter_{}.solverstate'.format(
disc_prefix, args.cont_iter))
loss_df = pd.read_csv(loss_file,
sep=' ',
header=0,
index_col=[0, 1])
loss_df = loss_df[:args.cont_iter + 1]
else:
columns = ['iteration', 'phase']
loss_df = pd.DataFrame(columns=columns).set_index(columns)
plot_file = '{}_{}.png'.format(args.out_prefix, fold)
# begin training GAN
try:
train_GAN_model(train_data, test_data, gen, disc, loss_df,
loss_file, plot_file, args)
except:
raise
gen.snapshot()
disc.snapshot()
raise
# force the number of filters to be square
n = int(np.ceil(np.sqrt(data.shape[0])))
padding = ((0, n ** 2 - data.shape[0]), (0, padsize), (0, padsize)) + ((0, 0),) * (data.ndim - 3)
data = np.pad(data, padding, mode='constant', constant_values=(padval, padval))
# tile the filters into an image
data = data.reshape((n, n) + data.shape[1:]).transpose((0, 2, 1, 3) + tuple(range(4, data.ndim + 1)))
data = data.reshape((n * data.shape[1], n * data.shape[3]) + data.shape[4:])
plt.imshow(data)
if __name__ == "__main__":
caffe.set_device(1)
caffe.set_mode_gpu()
caffe.set_random_seed(1000)
net_def = 'test_generate_cls_vector.prototxt'
net = caffe.Net(net_def, caffe.TRAIN)
net.forward()
# print net.blobs['data'].data.shape
# print net.blobs['bbox'].data.shape
# print net.blobs['seg'].data.shape
transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})
transformer.set_transpose('data', (2, 0, 1))
transformer.set_mean('data', np.array([104, 117, 123])) # mean pixel
transformer.set_raw_scale('data', 255) # the reference model operates on images in [0,255] range instead of [0,1]
transformer.set_channel_swap('data', (2, 1, 0)) # the reference model has channels in BGR order instead of RGB
def test_groups():
caffe.set_random_seed(800)
caffe.set_mode_gpu()
def runmodel(model):
m = open('tmp.model', 'w')
m.write(model)
m.close()
net = caffe.Net('tmp.model', caffe.TRAIN)
res = net.forward()
os.remove('tmp.model')
return res, net
#plain
res, net = runmodel('''layer {
name: "data"
type: "MolGridData"
top: "data"
top: "label"
top: "seqcont"
molgrid_data_param {
source: "typesfiles/grouped.types"
batch_size: 2
max_group_size: 4
dimension: 23.5
resolution: 0.5
shuffle: false
balanced: false
root_folder: "typesfiles"
}
}''')
labels = res['label']
seqcont = res['seqcont']
data = res['data']
assert labels.shape == (4, 2)
assert seqcont.shape == (4, 2)
assert list(seqcont[0]) == [0, 0]
assert list(seqcont[1]) == [1, 1]
assert data[3][0].sum() == 0
assert data[3][1].sum() == 0
res = net.forward()
labels = res['label']
seqcont = res['seqcont']
data = res['data']
assert labels.shape == (4, 2)
assert seqcont.shape == (4, 2)
assert list(seqcont[0]) == [0, 0]
assert list(seqcont[1]) == [1, 1]
assert data[3][0].sum() > 0
assert data[3][1].sum() > 0
#with chunks
res, net = runmodel('''layer {
name: "data"
type: "MolGridData"
top: "data"
top: "label"
top: "seqcont"
molgrid_data_param {
source: "typesfiles/grouped.types"
batch_size: 2
max_group_size: 4
max_group_chunk_size: 2
dimension: 23.5
resolution: 0.5
shuffle: false
balanced: false
root_folder: "typesfiles"
}
}''')
labels = res['label']
seqcont = res['seqcont']
data = res['data']
assert labels.shape == (2, 2)
assert seqcont.shape == (2, 2)
assert list(seqcont[0]) == [0, 0]
assert list(seqcont[1]) == [1, 1]
assert data[0][0].sum() > 0
assert data[0][1].sum() > 0
assert data[1][0].sum() > 0
assert data[1][1].sum() > 0
res = net.forward()
labels = res['label']
seqcont = res['seqcont']
data = res['data']
assert labels.shape == (2, 2)
assert seqcont.shape == (2, 2)
assert list(seqcont[0]) == [1, 1]
assert list(seqcont[1]) == [1, 1]
assert data[0][0].sum() > 0
assert data[0][1].sum() > 0
assert data[1][0].sum() == 0
assert data[1][1].sum() == 0
args = parse_args()
print('called with args:')
pprint.pprint(vars(args))
sys.path.insert(0, args.caffe_python_path)
import caffe
import caffe_tools
# get data
print 'loading roi infos from:', args.roi_infos_file, '...'
with open(args.roi_infos_file, 'rb') as f:
roi_infos = cPickle.load(f)
if not args.randomize:
np.random.seed(3)
caffe.set_random_seed(3)
# set up caffe
caffe.set_mode_gpu()
if args.gpu_id is not None:
caffe.set_device(args.gpu_id)
net = caffe.Net(args.net_prototxt, args.pretrained_model, caffe.TEST)
net.name = os.path.splitext(os.path.basename(args.pretrained_model))[0]
args.blob_names = args.blob_names.split(',')
args.outfiles = args.outfiles.split(',')
fws = [open(outfile, 'w') for outfile in args.outfiles]
print 'net:', args.net_prototxt
print 'data:', args.roi_infos_file
parser.add_argument('-i','--input',type=str,required=True,help="Input .types file to predict")
parser.add_argument('-g','--gpu',type=int,help='Specify GPU to run on',default=-1)
parser.add_argument('-o','--output',type=str,help='Output file name',default=None)
parser.add_argument('-s','--seed',type=int,help='Random seed',default=None)
parser.add_argument('-k','--keep',action='store_true',default=False,help="Don't delete prototxt files")
parser.add_argument('--rotations',type=int,help='Number of rotations; rotatation must be enabled in test net!',default=1)
parser.add_argument('--max_score',action='store_true',default=False,help="take max score per ligand as its score")
parser.add_argument('--max_affinity',action='store_true',default=False,help="take max affinity per ligand as its score")
parser.add_argument('--notcalc_predictions', type=str, default='',help='use file of predictions instead of calculating')
return parser.parse_args(argv)
if __name__ == '__main__':
args = parse_args()
if not args.output:
out = sys.stdout
else:
out = open(args.output, 'w')
if args.seed != None:
caffe.set_random_seed(args.seed)
if not args.notcalc_predictions:
predictions = predict_lines(args)
else:
with open(args.notcalc_predictions, 'r') as f:
predictions = f.readlines()
if args.max_score or args.max_affinity:
predictions = maxLigandScore(predictions, args.max_affinity)
out.writelines(predictions)
print('[INFO] Called with args:')
print(args)
# setup & load configs
_C = Config(config_pn="config/config.ini")
cfg = _C.cfg
cfg.MAIN_DEFAULT_GPU_ID = args['gpu_id']
print('Using config:')
pprint.pprint(cfg)
if not args['rand']:
# fix the random seeds (numpy and caffe) for reproducibility
np.random.seed(cfg.MAIN_DEFAULT_RNG_SEED)
caffe.set_random_seed(cfg.MAIN_DEFAULT_RNG_SEED)
# set up caffe
caffe.set_mode_gpu()
caffe.set_device(args['gpu_id'])
print('[INFO] loading dataset {} for training...'.format(args["dataset"]))
dataset_DIR = osp.join(cfg.MAIN_DIR_ROOT, "data", args["dataset"])
gt_set = args['gt_set']
task = args['task']
in_gt_dir = args['in_gt_dir']
in_pr_dir = args['in_pr_dir']
dataset = None
ds_pascal = ["voc_2007", "bsd_voc2012"]
def train_action_net():
args = parse_args()
print('Called with args:')
print(args)
print
print
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
print('Using config:')
pprint.pprint(cfg)
print
print
# Fix the random seeds (numpy and caffe) for reproducibility
if not args.randomize:
np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
# Set up caffe
caffe.set_mode_gpu()
if args.gpu_id is not None:
caffe.set_device(args.gpu_id)
#
print "args.imdb_name:", args.imdb_name
# get_imdb(args.imdb_name) == action_datasets.rcnn_action(datatype, split)
# where datatype is the name of action dataset, like:
# PascalVoc2012, Willowactions, Stanford, MPII
# where split indicates the train/val/trainval/test
# instance of action_datasets.rcnn_action, **note that rcnn_action inherits imdb**
#
# imdb_name: rcnn_<datatype>_<imageset>
# where datatype: PascalVoc2012, Willowactions, Stanford, MPII, or more...
# imageset: train, val, trainval, test
imdb = get_imdb(args.imdb_name)
#
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
roidb = get_training_roidb(imdb)
#
sub_dir = "action_output"
output_dir = get_output_dir(imdb=imdb, sub_dir=sub_dir, net=None)
print 'Output will be saved to `{:s}`'.format(output_dir)
exper_name = args.exper_name
if exper_name:
print "exper_name:", exper_name
re_iter = args.re_iter
sleep_time = 5
while not os.path.exists(args.pretrained_model) and args.wait:
print('Waiting for {} to exist...'.format(args.pretrained_model))
time.sleep(sleep_time)
print "Initialize from", args.pretrained_model
#
train_net(args.solver, roidb, output_dir,
pretrained_model=args.pretrained_model, \
max_iters=args.max_iters, \
exper_name=exper_name, \
re_iter=re_iter)
def_cfg('UDET')
cfg_from_file(cfg)
pprint.pprint(fconfig.cfg)
caffe.set_mode_gpu()
caffe.set_device(gpu_id)
# setup the dataset's path
dataset = os.path.join('..', 'data', imdb_name)
# load pixel mean
pixel_means = None
if os.path.exists(os.path.join(dataset, 'mean.npy')):
pixel_means = np.load(os.path.join(dataset, 'mean.npy'))
fconfig.cfg.PIXEL_MEANS = pixel_means
print 'Loaded mean.npy: {}'.format(pixel_means)
else:
print 'Cannot find mean.npy and we will use default mean.'
imdb = IMDB()
imdb.get_roidb(load_data_with_boxes, dataset=dataset)
roidb = get_training_roidb(imdb)
np.random.seed(fconfig.cfg.RNG_SEED)
caffe.set_random_seed(fconfig.cfg.RNG_SEED)
train_net(solver,
roidb,
out,
pretrained_model=pretrained_model,
max_iters=max_iters)
print('Called with args:')
print(args)
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
print('Using config:')
pprint.pprint(cfg)
if not args.randomize:
# fix the random seeds (numpy and caffe) for reproducibility
np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
# set up caffe
caffe.set_mode_gpu()
if args.gpu_id is not None:
caffe.set_device(args.gpu_id)
imdb = get_imdb(args.imdb_name)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
roidb = get_training_roidb(imdb)
output_dir = get_output_dir(imdb, None)
print 'Output will be saved to `{:s}`'.format(output_dir)
# roidb_s,roidb_w, = weakly_supervised_roidb(roidb)
def main():
args = parse_args()
print('Called with args:')
print(args)
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
cfg.GPU_ID = args.gpu_id
# fix the random seeds (numpy and caffe) for reproducibility
np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
# set up caffe
caffe.set_mode_gpu()
caffe.set_device(cfg.GPU_ID)
# queue for communicated results between processes
mp_queue = mp.Queue()
print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
print 'Stage 1 RPN, init from ImageNet model'
print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
cfg.TRAIN.SNAPSHOT_INFIX = 'stage1'
rpn_stage1_out = train_rpn(imdb_names=args.imdb_name,
init_model=args.pretrained_model,
solver=args.solver,
max_iters=args.max_iters,
cfg=cfg)
# mp_kwargs = dict(
# queue=mp_queue,
# imdb_names=args.imdb_name,
# init_model=args.pretrained_model,
# solver=args.solver,
# max_iters=args.max_iters,
# cfg=cfg)
# p = mp.Process(target=train_rpn, kwargs=mp_kwargs)
# p.start()
# rpn_stage1_out = mp_queue.get()
# p.join()
# rpn_stage1_out = \
# {'model_path': '/home/leoyolo/research/py-faster-rcnn-another/output/rpn_small_obj/voc_2007_trainval/vgg_cnn_m_1024_rpn_small_obj_stage1_iter_80000.caffemodel'}
print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
print 'Stage 1 RPN, generate proposals for the test set'
print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
rpn_stage1_out['proposal_path'] = \
rpn_generate(imdb_name=args.test_imdb_name,
rpn_model_path=str(rpn_stage1_out['model_path']),
cfg=cfg,
rpn_test_prototxt=args.rpn_test_prototxt
)['proposal_path']
# mp_kwargs = dict(
# queue=mp_queue,
# imdb_name=args.test_imdb_name,
# rpn_model_path=str(rpn_stage1_out['model_path']),
# cfg=cfg,
# rpn_test_prototxt=args.rpn_test_prototxt)
# p = mp.Process(target=rpn_generate, kwargs=mp_kwargs)
# p.start()
# rpn_stage1_out['proposal_path'] = mp_queue.get()['proposal_path']
# p.join()
for area in ['all', 'small', 'medium', 'large']:
print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
print 'Stage 1 RPN, eval recall with area {}'.format(area)
print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
rpn_test(imdb_name=args.test_imdb_name,
rpn_proposal_path=rpn_stage1_out['proposal_path'],
area=area)
