Exemple #1
0
  def get_trainer_by_name(name, param_dict):
    net = FastNet(param_dict['image_shape'])
    if name == 'layerwise':
      param_dict['net'] = net
      return ImageNetLayerwisedTrainer(**param_dict)

    net = FastNet(param_dict['image_shape'])
    load_model(net, param_dict['init_model'])
    param_dict['net'] = net
    if name == 'normal':
      return Trainer(**param_dict)
    elif name == 'minibatch':
      return MiniBatchTrainer(**param_dict)
    else:
      raise Exception, 'No trainer found for name: %s' % name
Exemple #2
0
  def get_trainer_by_name(name, param_dict):
    net = FastNet(param_dict['image_shape'])
    if name == 'layerwise':
      param_dict['net'] = net
      return ImageNetLayerwisedTrainer(**param_dict)

    net = FastNet(param_dict['image_shape'])
    load_model(net, param_dict['init_model'])
    param_dict['net'] = net
    if name == 'normal':
      return Trainer(**param_dict)
    elif name == 'minibatch':
      return MiniBatchTrainer(**param_dict)
    else:
      raise Exception, 'No trainer found for name: %s' % name
Exemple #3
0
def test_checkpoint():
  net1 = _make_simple()
  cp = checkpoint.CheckpointDumper('/tmp/', 'cp_test')
  
  model = {}
  model['layers'] = net1.get_dumped_layers()
  cp.dump(model)
  
  net2 = parser.load_model(net.FastNet((3, 32, 32)), cp.get_checkpoint())
  
  for l1, l2 in zip(net1, net2):
    assert l1.name == l2.name, (l1.name, l2.name)
    if hasattr(l1, 'weight'):
      assert np.all((l1.weight.wt == l2.weight.wt).get())
      assert np.all((l1.bias.wt == l2.bias.wt).get())
Exemple #4
0
train_dp = data.get_by_name(data_provider)(data_dir, train_range)
test_dp = data.get_by_name(data_provider)(data_dir, test_range)
checkpoint_dumper = trainer.CheckpointDumper(checkpoint_dir, test_id)

model = checkpoint_dumper.get_checkpoint()
if model is None:
    model = parser.parse_config_file(param_file)

save_freq = 100000
test_freq = 1000
adjust_freq = 100000
factor = 1
num_batch = 1
learning_rate = 0.1
batch_size = 128
image_color = 3
image_size = 224
image_shape = (image_color, image_size, image_size, batch_size)
net = parser.load_model(net.FastNet(image_shape), model)

param_dict = globals()

#num_batch = 1
#t = trainer.MiniBatchTrainer(**param_dict)
t = trainer.Trainer(**param_dict)

for layer in ['conv1', 'conv2', 'conv3', 'conv4', 'conv5']:
    t.train(num_epochs)
    net.get_layer_by_name(layer).disable_bprop()
test_range = range(6, 7) #41, 42, ..., 48
data_provider = 'cropped-cifar10'


multiview = False
train_dp = data.get_by_name(data_provider)(data_dir,train_range)
test_dp = data.get_by_name(data_provider)(data_dir, test_range, multiview = multiview)
checkpoint_dumper = trainer.CheckpointDumper(checkpoint_dir, test_id)

init_model = checkpoint_dumper.get_checkpoint()
if init_model is None:
  init_model = parser.parse_config_file(param_file)

save_freq = 100
test_freq = 100
adjust_freq = 100
factor = 1
num_epoch = 10
learning_rate = 0.01
batch_size = 64
image_color = 3
image_size = 24
image_shape = (image_color, image_size, image_size, batch_size)

net = parser.load_model(net.FastNet(image_shape), init_model)

param_dict = globals()
t = trainer.Trainer(**param_dict)
#t.train(num_epoch)
t.predict()
Exemple #6
0
checkpoint_dir = './checkpoint'
param_file = 'config/imagenet.cfg'

train_range = range(101, 1301)
test_range = range(1, 101)

data_provider = 'imagenet'
#train_range = range(1, 41)
#test_range = range(41, 49)

train_dp = data.get_by_name(data_provider)(data_dir,train_range)
test_dp = data.get_by_name(data_provider)(data_dir, test_range)

model = parser.parse_config_file(param_file)
network = net.FastNet((3, 224, 224, 1))
network = parser.load_model(network, model)

class Tags(object):
  GRAD_SEND = 100
  WEIGHT_UPDATE = 200


def tobuffer(gpuarray):
  #print 'BUFFER: 0x%x' % gpuarray.ptr
  #print 'SIZE: %s, %s, %s' % (gpuarray.size, gpuarray.shape, gpuarray.dtype) 
  dtype = np.dtype(gpuarray.dtype)
  buf = ctypes.pythonapi.PyBuffer_FromReadWriteMemory(ctypes.c_long(gpuarray.ptr),
                                                      gpuarray.size * dtype.itemsize)
  return ctypes.cast(buf, ctypes.py_object).value

def wait_for_all(reqs):
Exemple #7
0
checkpoint_dir = './checkpoint'
param_file = 'config/imagenet.cfg'

train_range = range(101, 1301)
test_range = range(1, 101)

data_provider = 'imagenet'
#train_range = range(1, 41)
#test_range = range(41, 49)

train_dp = data.get_by_name(data_provider)(data_dir, train_range)
test_dp = data.get_by_name(data_provider)(data_dir, test_range)

model = parser.parse_config_file(param_file)
network = net.FastNet((3, 224, 224, 1))
network = parser.load_model(network, model)


class Tags(object):
    GRAD_SEND = 100
    WEIGHT_UPDATE = 200


def tobuffer(gpuarray):
    #print 'BUFFER: 0x%x' % gpuarray.ptr
    #print 'SIZE: %s, %s, %s' % (gpuarray.size, gpuarray.shape, gpuarray.dtype)
    dtype = np.dtype(gpuarray.dtype)
    buf = ctypes.pythonapi.PyBuffer_FromReadWriteMemory(
        ctypes.c_long(gpuarray.ptr), gpuarray.size * dtype.itemsize)
    return ctypes.cast(buf, ctypes.py_object).value