def initialize(self, input_dim=0, output_dim=5, isPredict=False):
# self.batch_size = 64
if isPredict == True:
self.input_dim = input_dim
self.output_dim = output_dim
# Symbols...........................................
self.X = tf.placeholder(tf.float32, shape=[None, self.input_dim])
self.Y = tf.placeholder(tf.float32, shape=[None, self.output_dim])
# with tf.device('/device:GPU:0'): # You can activate it for GPU version
with tf.name_scope('model'):
self.model = models.MLP_Model(inputs=self.X,
input_dim=self.input_dim,
hiddens=self.hiddens,
output2_dim=self.output_dim,
batch_size=self.batch_size,
model_name="model_1",
mode=self.initialization)
with tf.name_scope('optimizer'):
self.optimizer = optimizers.Optimizer(lr=self.learning_rate,
mode=self.mlp_optimizer,
model=self.model,
y=self.Y)
with tf.name_scope('generator'):
self.generator = optimizers.Generator(model=self.model)
# Session Initialization............................
# self.sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))
self.sess = tf.Session()
self.sess.run(tf.global_variables_initializer())
self.saver = tf.train.Saver(
) # Add ops to save and restore all the variables.
def test_OptimizeOverMultipleEncoders(self):
"""Run the optimizer for a few cycles with a real codec.
This may turn out to be an over-heavy test for every-checkin testing."""
my_fileset = test_tools.TestFileSet()
my_codec = vp8.Vp8Codec()
my_optimizer = optimizer.Optimizer(
my_codec, my_fileset, cache_class=encoder.EncodingDiskCache)
# Establish a baseline.
for bitrate, videofile_name in my_fileset.AllFilesAndRates():
videofile = encoder.Videofile(videofile_name)
my_encoding = my_optimizer.BestEncoding(bitrate, videofile)
my_encoding.Execute().Store()
# Try to improve it.
encoding_count = 0
while encoding_count < 10:
(bitrate,
videofile_name) = random.choice(my_fileset.AllFilesAndRates())
videofile = encoder.Videofile(videofile_name)
next_encoding = my_optimizer.BestUntriedEncoding(
bitrate, videofile)
if not next_encoding:
break
encoding_count += 1
next_encoding.Execute().Store()
def ListOneTarget(codecs,
rate,
videofile,
do_score,
datatable,
score_function=None):
"""Extend a datatable with the info about one video file's scores."""
for codec_name in codecs:
# For testing:
# Allow for direct context injection rather than picking by name.
if isinstance(codec_name, basestring):
codec = pick_codec.PickCodec(codec_name)
my_optimizer = optimizer.Optimizer(codec,
score_function=score_function)
else:
my_optimizer = codec_name
codec_name = my_optimizer.context.codec.name
bestsofar = my_optimizer.BestEncoding(rate, videofile)
if do_score and not bestsofar.Result():
bestsofar.Execute()
bestsofar.Store()
assert (bestsofar.Result())
# Ignore results that score less than zero.
if my_optimizer.Score(bestsofar) < 0.0:
return
(datatable.setdefault(codec_name,
{}).setdefault(videofile.basename, []).append(
(bestsofar.result['bitrate'],
bestsofar.result['psnr'])))
def test_BestOverallConfigurationNotInWorkDirectory(self):
other_dir = os.path.join(encoder_configuration.conf.sysdir(),
'multirepo_test')
os.mkdir(other_dir)
encoder_configuration.conf.override_scorepath_for_test([other_dir])
self.file_set = optimizer.FileAndRateSet(verify_files_present=False)
self.file_set.AddFilesAndRates([self.videofile.filename], [100, 200])
self.optimizer = optimizer.Optimizer(self.codec, self.file_set)
# When there is nothing in the database, None should be returned.
best_encoder = self.optimizer.BestOverallEncoder()
self.assertIsNone(best_encoder)
# Fill in the database with all the files and rates.
other_context = encoder.Context(self.codec,
encoder.EncodingDiskCache,
scoredir='multirepo_test')
my_encoder = self.EncoderFromParameterString('--score=7')
other_context.cache.StoreEncoder(my_encoder)
my_encoder.context.cache.StoreEncoder(my_encoder)
for rate, filename in self.file_set.AllFilesAndRates():
my_encoding = my_encoder.Encoding(rate,
encoder.Videofile(filename))
my_encoding.Execute()
other_context.cache.StoreEncoding(my_encoding)
# The best encoder should now be from the workdir, but the results are
# all fetched from the searchpath.
best_encoder = self.optimizer.BestOverallEncoder()
self.assertTrue(best_encoder)
self.assertEquals(my_encoder.parameters.ToString(),
best_encoder.parameters.ToString())
one_encoding = best_encoder.Encoding(100, self.videofile)
one_encoding.Recover()
self.assertTrue(one_encoding.Result())
def example2():
lattice = at.load_tracy('../atip/atip/rings/for_Tobyn.lat')
qd2s = lattice.get_elements('qd2')
qd5s = lattice.get_elements('qd5')
qd3s = lattice.get_elements('qd3')
qf1s = lattice.get_elements('qf1')
qf6s = lattice.get_elements('qf6')
vals = [
qd2s[0].PolynomB[1], qd5s[0].PolynomB[1], qd3s[0].PolynomB[1],
qf1s[0].PolynomB[1], qf6s[0].PolynomB[1]
]
# The generalisation from example1 could be taken further e.g. using:
def edit_family(ring, ffc, value):
family, field, cell = ffc
for elem in ring.get_elements(family):
vars(elem)[field][cell] = value
variables = o.Variables(
[edit_family, edit_family, edit_family, edit_family, edit_family],
[('qd2', 'PolynomB', 1), ('qd5', 'PolynomB', 1),
('qd3', 'PolynomB', 1), ('qf1', 'PolynomB', 1),
('qf6', 'PolynomB', 1)], vals)
constraints = o.Constraints(
lattice, {'eta_x': [[0, 52, 103], [0, 0.02, 0], [5, 1, 5]]})
optimizer = o.Optimizer(constraints, variables)
return optimizer.run(verbosity=1)
def __init__(self, args):
super(Trainer, self).__init__()
self.args = args
self.num_gpus = torch.cuda.device_count()
self.distributed = self.num_gpus > 1
if self.distributed:
torch.cuda.set_device(args.local_rank)
torch.distributed.init_process_group(backend="nccl",
init_method="env://")
self.device = torch.device("cuda")
if cfg.SEED > 0:
random.seed(cfg.SEED)
torch.manual_seed(cfg.SEED)
torch.cuda.manual_seed_all(cfg.SEED)
self.setup_logging()
self.load_data()
self.iteration = 0
self.models = []
self.optims = []
self.names = []
for i in range(len(cfg.MODEL.NETS)):
in_dim = utils.get_dim(i)
model = models.create(cfg.MODEL.NETS[i],
in_dim=in_dim,
out_dim=cfg.MODEL.EMBED_DIM[i]).cuda()
optim = optimizer.Optimizer(model)
self.models.append(model)
self.optims.append(optim)
self.names.append(cfg.MODEL.NAMES[i])
def run_optimization(indiv, filename=None, button=True):
optimizer = OPT.Optimizer(indiv.uid, indiv.phenotype)
if filename == None:
filename = indiv.uid
optimizer.optimize_size(filename, button=True)
else:
optimizer.optimize_size(filename, button=True)
def setData(self, courses_path, rooms_path, no_conflicts_path, b2b_path):
"""Populate the optimizer"""
self.isBuilt = False
try:
self.rooms = readData.importRoomInventory(rooms_path)
no_conflicts = readData.importNoConflictGroups(no_conflicts_path)
self.courses = readData.importCourses(courses_path, self.rooms)
b2b_pairs = readData.importB2BPairs(b2b_path, self.courses)
self.optimizer = opt.Optimizer(self.courses,
self.rooms,
config.Options(),
no_conflicts,
quiet=self.quiet,
b2b_pairs=b2b_pairs)
except ses.SESError as e:
print e
pub.sendMessage("status_bar.error", str(e))
except Exception as e:
print e
pub.sendMessage("status_bar.error", str(e))
else:
self.resetCourses()
pub.sendMessage("data_loaded")
def StdOptimizer(self):
# This function is not in setup because some tests
# do not need it.
if not self.optimizer:
self.optimizer = optimizer.Optimizer(self.codec, self.file_set,
cache_class=self.cache_class)
return self.optimizer
def test_AlternateScorer(self):
my_optimizer = optimizer.Optimizer(self.codec, self.file_set,
cache_class=self.cache_class,
score_function=Returns1)
my_optimizer.BestEncoding(100, self.videofile).Execute().Store()
self.assertEqual(1,
my_optimizer.Score(my_optimizer.BestEncoding(100, self.videofile)))
def test_VerifyCorruptedFile(self):
codec = CorruptingCodec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
self.assertFalse(encoding.VerifyEncode())
def test_OneBlackFrame(self):
codec = CopyingCodec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
self.assertTrue(encoding.Result())
def test_OneBlackFrame(self):
codec = mjpeg.MotionJpegCodec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
# Motion JPEG generates a massive file, so give it a large target bitrate.
encoding = my_optimizer.BestEncoding(5000, videofile)
encoding.Execute()
self.assertLess(50.0, my_optimizer.Score(encoding))
def setUp(self):
mod = 'y ~ x'
self.coeff = 3
x = [10 + np.random.rand() for _ in range(40)]
y = [self.coeff * x for x in x]
d = DataFrame(np.array([x, y]).T, columns=['x', 'y'])
self.model = model.Model(mod)
self.model.load_dataset(d)
self.opt = optimizer.Optimizer(self.model)
def test_TenBlackFrames(self):
codec = openh264.OpenH264Codec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithBlankFrames(
'ten_black_frames_1024_768_30.yuv', 10)
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
# Most codecs should be good at this.
self.assertLess(40.0, my_optimizer.Score(encoding))
def test_MoreBlackFrames(self):
codec = hevc_jm.HevcCodec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithBlankFrames(
'more_black_frames_1024_768_30.yuv', 8)
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
# Most codecs should be good at this.
self.assertLess(40.0, my_optimizer.Score(encoding))
def test_OneBlackFrame(self):
codec = vp8_mpeg.Vp8CodecMpegMode()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
# Most codecs should be good at this.
self.assertLess(50.0, my_optimizer.Score(encoding))
def test_OneBlackFrame(self):
codec = h261.H261Codec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
# H.261 does badly at generating a black frame. Bug?
self.assertLess(48.0, my_optimizer.Score(encoding))
def test_SuggestedTweakRefersToSameContext(self):
codec = vp8_mpeg.Vp8CodecMpegMode()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
# Fake result.
encoding.result = {'psnr': 42.0, 'bitrate': 1000}
next_encoding = codec.SuggestTweak(encoding)
self.assertEqual(encoding.context, next_encoding.context)
def test_VerifyMd5Varies(self):
codec = CorruptingCodec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
first_md5 = encoding.Result()['yuv_md5']
encoding.Execute()
self.assertNotEqual(first_md5, encoding.Result()['yuv_md5'])
def test_SuggestTweakDecreasesCq(self):
codec = vp8_mpeg_1d.Vp8CodecMpeg1dMode()
videofile = encoder.Videofile('foofile_640_480_30.yuv')
my_optimizer = optimizer.Optimizer(codec)
my_encoder = codec.StartEncoder(my_optimizer.context)
encoding = encoder.Encoding(my_encoder, 500, videofile)
encoding.result = {'bitrate': 200}
# Since the bitrate is too high, the suggstion should be to increase it.
new_encoding = codec.SuggestTweak(encoding)
self.assertEqual('0',
new_encoding.encoder.parameters.GetValue('key-q'))
def test_MultipleOptimizers(self):
# Make sure other score directories don't interfere with this test.
encoder_configuration.conf.override_scorepath_for_test([])
os.mkdir(os.path.join(encoder_configuration.conf.sysdir(),
'first_dir'))
os.mkdir(
os.path.join(encoder_configuration.conf.sysdir(), 'second_dir'))
one_optimizer = optimizer.Optimizer(self.codec, scoredir='first_dir')
another_optimizer = optimizer.Optimizer(self.codec,
scoredir='second_dir')
self.assertNotEqual(one_optimizer.context.cache.workdir,
another_optimizer.context.cache.workdir)
# Storing one encoding's score should not affect the other's.
one_encoding = one_optimizer.BestEncoding(100, self.videofile)
one_encoding.Execute().Store()
another_encoding = another_optimizer.BestEncoding(100, self.videofile)
self.assertFalse(another_encoding.Result())
another_encoding.Recover()
self.assertFalse(another_encoding.Result())
def test_VerifyMatroskaFile(self):
codec = vp8.Vp8Codec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
# Matroska files will be identical if generated within the same
# clock second. So wait a bit.
time.sleep(1)
self.assertTrue(encoding.VerifyEncode())
def recompile_block(self, compiled_block):
# Recompile the block using the flow actions for optimisation.
recompiled_blocks = []
flow_parser = flow_actions.FlowActions().make_parser()
opt = optimizer.Optimizer(parser=flow_parser)
opt.push_nodes(compiled_block.nodes)
opt.compile_to(type(compiled_block), recompiled_blocks)
# Return the recompiled block. Note that there can be only one block
# in the list because recompilation cannot introduce new code blocks or
# new data blocks.
return recompiled_blocks[0]
def test_AutoGenerateClipTime(self):
my_optimizer = optimizer.Optimizer(self.codec, self.file_set,
cache_class=self.cache_class,
score_function=ReturnsClipTime)
my_encoder = encoder.Encoder(my_optimizer.context,
encoder.OptionValueSet(encoder.OptionSet(), ''))
# Must use a tricked-out videofile to avoid disk access.
videofile = DummyVideofile('test_640x480_20.yuv', clip_time=1)
my_encoding = encoder.Encoding(my_encoder, 123, videofile)
my_encoding.result = {'psnr':42, 'bitrate':123}
# If cliptime is not present, this will raise an exception.
my_optimizer.Score(my_encoding)
def example1():
lattice = at.load_tracy('../atip/atip/rings/for_Tobyn.lat')
for index, elem in enumerate(lattice):
elem.Index = index
qf1s = lattice.get_elements('qf1')
qd2s = lattice.get_elements('qd2')
indices = [qf1s[0].Index, qd2s[0].Index]
vals = [qf1s[0].PolynomB[1], qd2s[0].PolynomB[1]]
def edit_qf1s(ring, index, value):
for elem in ring.get_elements('qf1'):
elem.PolynomB[1] = value
def edit_qd2s(ring, index, value):
for elem in ring.get_elements('qd2'):
elem.PolynomB[1] = value
# Initial tunes are [0.44751328688229897, 0.5254100397314794]
variables = o.Variables([edit_qf1s, edit_qd2s], indices, vals)
constraints = o.Constraints(lattice, {
'tune_x': [[], [0.36], [2]],
'tune_y': [[], [0.64], [1]]
})
opt = o.Optimizer(constraints, variables)
lat = opt.run(verbosity=1, gtol=None)
# N.B. we can also be clever; beacuse index is not used by our custom
# family editing function we can do the following:
def edit_family_b1(ring, family, value):
for elem in ring.get_elements(family):
elem.PolynomB[1] = value
variables = o.Variables([edit_family_b1, edit_family_b1], ['qf1', 'qd2'],
vals)
constraints = o.Constraints(lattice, {
'tune_x': [[], [0.36], [2]],
'tune_y': [[], [0.64], [1]]
})
optimizer = o.Optimizer(constraints, variables)
return optimizer.run(verbosity=1, gtol=None)
def ListOneTarget(codecs,
rate,
videofile,
do_score,
datatable,
score_function=None,
full_results=False):
"""Extend a datatable with the info about one video file's scores."""
for codec_name in codecs:
# For testing:
# Allow for direct context injection rather than picking by name.
if isinstance(codec_name, basestring):
codec = pick_codec.PickCodec(codec_name)
my_optimizer = optimizer.Optimizer(codec,
score_function=score_function)
else:
my_optimizer = codec_name
codec_name = my_optimizer.context.codec.name
bestsofar = my_optimizer.BestEncoding(rate, videofile)
if do_score and not bestsofar.Result():
bestsofar.Execute()
bestsofar.Store()
assert (bestsofar.Result())
# Ignore results that score less than zero.
if my_optimizer.Score(bestsofar) < 0.0:
return
if full_results:
# Datatable is a dictionary of codec name -> result sets.
# Each result set is an array containing result info.
# Each result info is a dictionary containing the
# ID of the configuration used, the
# target bitrate, the command line, the score and the result.
(datatable.setdefault(codec_name, {}).setdefault(
videofile.basename, []).append({
'config_id':
bestsofar.encoder.Hashname(),
'target_bitrate':
rate,
'encode_command':
bestsofar.EncodeCommandLine(),
'score':
my_optimizer.Score(bestsofar),
'result':
bestsofar.ResultWithoutFrameData()
}))
else:
# Datatable is a dictionary of codec name -> result sets.
# Each result set is an array containing result info.
# Each result info contains the achieved bitrate and the PSNR.
(datatable.setdefault(codec_name, {}).setdefault(
videofile.basename, []).append(
(bestsofar.result['bitrate'], bestsofar.result['psnr'])))
def test_BitrateSensitivity(self):
# Verify that bitrate varies at all when target bitrate
# is changed. Hitting the bitrate is not tested.
codec = openh264.OpenH264Codec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithNoisyFrames(
'many_noisy_frames_1024_768_30.yuv', 10)
encoding1 = my_optimizer.BestEncoding(1000, videofile)
encoding1.Execute()
encoding2 = my_optimizer.BestEncoding(10, videofile)
encoding2.Execute()
self.assertNotEquals(encoding1.result['bitrate'],
encoding2.result['bitrate'])
def test_ParametersSet(self):
codec = mjpeg.MotionJpegCodec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
my_encoder = encoder.Encoder(
my_optimizer.context,
encoder.OptionValueSet(codec.option_set,
'-qmin 1 -qmax 1',
formatter=codec.option_formatter))
encoding = my_encoder.Encoding(5000, videofile)
encoding.Execute()
self.assertLess(50.0, my_optimizer.Score(encoding))
def test_FfmpegFrameInfo(self):
codec = vp8.Vp8Codec()
my_optimizer = optimizer.Optimizer(codec)
videofile = test_tools.MakeYuvFileWithOneBlankFrame(
'one_black_frame_1024_768_30.yuv')
encoding = my_optimizer.BestEncoding(1000, videofile)
encoding.Execute()
# This line comes from file_codec.Execute()
encodedfile = '%s/%s.%s' % (encoding.Workdir(), videofile.basename,
codec.extension)
frameinfo = file_codec.FfmpegFrameInfo(encodedfile)
self.assertEquals(len(frameinfo), 1)
self.assertGreater(
os.path.getsize(encodedfile) * 8, frameinfo[0]['size'])
