def batch_func(self, param ): samples, index2d_host, = param bs = self.batch_size while True: person_idxs = index2d_host.get_1D(bs) samples_idxs = index2d_host.get_2D(person_idxs, 1) batches = None for n_batch in range(bs): person_id = person_idxs[n_batch] sample_idx = samples_idxs[n_batch][0] sample = samples[ sample_idx ] try: x, = SampleProcessor.process ([sample], self.sample_process_options, self.output_sample_types, self.debug) except: raise Exception ("Exception occured in sample %s. Error: %s" % (sample.filename, traceback.format_exc() ) ) if batches is None: batches = [ [] for _ in range(len(x)) ] batches += [ [] ] i_person_id = len(batches)-1 for i in range(len(x)): batches[i].append ( x[i] ) batches[i_person_id].append ( np.array([person_id]) ) yield [ np.array(batch) for batch in batches]
def __init__(self, samples_path, debug, batch_size, sample_process_options=SampleProcessor.Options(), output_sample_types=[], raise_on_no_data=True, **kwargs): super().__init__(debug, batch_size) self.initialized = False self.sample_process_options = sample_process_options self.output_sample_types = output_sample_types samples = SampleLoader.load(SampleType.IMAGE, samples_path) if len(samples) == 0: if raise_on_no_data: raise ValueError('No training data provided.') return self.generators = [ThisThreadGenerator ( self.batch_func, samples )] if self.debug else \ [SubprocessGenerator ( self.batch_func, samples )] self.generator_counter = -1 self.initialized = True
def batch_func(self, samples): samples_len = len(samples) idxs = [ *range(samples_len) ] shuffle_idxs = [] while True: batches = None for n_batch in range(self.batch_size): if len(shuffle_idxs) == 0: shuffle_idxs = idxs.copy() np.random.shuffle (shuffle_idxs) idx = shuffle_idxs.pop() sample = samples[idx] x, = SampleProcessor.process ([sample], self.sample_process_options, self.output_sample_types, self.debug) if batches is None: batches = [ [] for _ in range(len(x)) ] for i in range(len(x)): batches[i].append ( x[i] ) yield [ np.array(batch) for batch in batches]
def __init__(self, samples_path, debug=False, batch_size=1, random_ct_samples_path=None, sample_process_options=SampleProcessor.Options(), output_sample_types=[], add_sample_idx=False, generators_count=4, **kwargs): super().__init__(samples_path, debug, batch_size) self.sample_process_options = sample_process_options self.output_sample_types = output_sample_types self.add_sample_idx = add_sample_idx if self.debug: self.generators_count = 1 else: self.generators_count = max(1, generators_count) samples = SampleHost.load(SampleType.FACE, self.samples_path) self.samples_len = len(samples) if self.samples_len == 0: raise ValueError('No training data provided.') index_host = mplib.IndexHost(self.samples_len) if random_ct_samples_path is not None: ct_samples = SampleHost.load(SampleType.FACE, random_ct_samples_path) ct_index_host = mplib.IndexHost(len(ct_samples)) else: ct_samples = None ct_index_host = None pickled_samples = pickle.dumps(samples, 4) ct_pickled_samples = pickle.dumps( ct_samples, 4) if ct_samples is not None else None if self.debug: self.generators = [ ThisThreadGenerator( self.batch_func, (pickled_samples, index_host.create_cli(), ct_pickled_samples, ct_index_host.create_cli() if ct_index_host is not None else None)) ] else: self.generators = [ SubprocessGenerator( self.batch_func, (pickled_samples, index_host.create_cli(), ct_pickled_samples, ct_index_host.create_cli() if ct_index_host is not None else None), start_now=True) for i in range(self.generators_count) ] self.generator_counter = -1
def __init__(self, samples_path, debug=False, batch_size=1, sample_process_options=SampleProcessor.Options(), output_sample_types=[], person_id_mode=1, generators_count=2, generators_random_seed=None, **kwargs): super().__init__(samples_path, debug, batch_size) self.sample_process_options = sample_process_options self.output_sample_types = output_sample_types self.person_id_mode = person_id_mode if generators_random_seed is not None and len( generators_random_seed) != generators_count: raise ValueError("len(generators_random_seed) != generators_count") self.generators_random_seed = generators_random_seed samples = SampleLoader.load(SampleType.FACE, self.samples_path, person_id_mode=True) if person_id_mode == 1: new_samples = [] for s in samples: new_samples += s samples = new_samples np.random.shuffle(samples) self.samples_len = len(samples) if self.samples_len == 0: raise ValueError('No training data provided.') if self.debug: self.generators_count = 1 self.generators = [ iter_utils.ThisThreadGenerator(self.batch_func, (0, samples)) ] else: self.generators_count = min(generators_count, self.samples_len) if person_id_mode == 1: self.generators = [ iter_utils.SubprocessGenerator( self.batch_func, (i, samples[i::self.generators_count])) for i in range(self.generators_count) ] else: self.generators = [ iter_utils.SubprocessGenerator(self.batch_func, (i, samples)) for i in range(self.generators_count) ] self.generator_counter = -1
def __init__ (self, samples_path, debug, batch_size, temporal_image_count=3, sample_process_options=SampleProcessor.Options(), output_sample_types=[], generators_count=2, **kwargs): super().__init__(debug, batch_size) self.temporal_image_count = temporal_image_count self.sample_process_options = sample_process_options self.output_sample_types = output_sample_types if self.debug: self.generators_count = 1 else: self.generators_count = generators_count samples = SampleLoader.load (SampleType.FACE_TEMPORAL_SORTED, samples_path) samples_len = len(samples) if samples_len == 0: raise ValueError('No training data provided.') mult_max = 1 l = samples_len - ( (self.temporal_image_count)*mult_max - (mult_max-1) ) index_host = mplib.IndexHost(l+1) pickled_samples = pickle.dumps(samples, 4) if self.debug: self.generators = [ThisThreadGenerator ( self.batch_func, (pickled_samples, index_host.create_cli(),) )] else: self.generators = [SubprocessGenerator ( self.batch_func, (pickled_samples, index_host.create_cli(),) ) for i in range(self.generators_count) ] self.generator_counter = -1
def batch_func(self, param): mult_max = 1 bs = self.batch_size pickled_samples, index_host = param samples = pickle.loads(pickled_samples) while True: batches = None indexes = index_host.multi_get(bs) for n_batch in range(self.batch_size): idx = indexes[n_batch] temporal_samples = [] mult = np.random.randint(mult_max)+1 for i in range( self.temporal_image_count ): sample = samples[ idx+i*mult ] try: temporal_samples += SampleProcessor.process ([sample], self.sample_process_options, self.output_sample_types, self.debug)[0] except: raise Exception ("Exception occured in sample %s. Error: %s" % (sample.filename, traceback.format_exc() ) ) if batches is None: batches = [ [] for _ in range(len(temporal_samples)) ] for i in range(len(temporal_samples)): batches[i].append ( temporal_samples[i] ) yield [ np.array(batch) for batch in batches]
def __init__ (self, samples_path, debug=False, batch_size=1, sample_process_options=SampleProcessor.Options(), output_sample_types=[], person_id_mode=1, **kwargs): super().__init__(samples_path, debug, batch_size) self.sample_process_options = sample_process_options self.output_sample_types = output_sample_types self.person_id_mode = person_id_mode samples_host = SampleHost.mp_host (SampleType.FACE, self.samples_path) samples = samples_host.get_list() self.samples_len = len(samples) if self.samples_len == 0: raise ValueError('No training data provided.') unique_person_names = { sample.person_name for sample in samples } persons_name_idxs = { person_name : [] for person_name in unique_person_names } for i,sample in enumerate(samples): persons_name_idxs[sample.person_name].append (i) indexes2D = [ persons_name_idxs[person_name] for person_name in unique_person_names ] index2d_host = mp_utils.Index2DHost(indexes2D) if self.debug: self.generators_count = 1 self.generators = [iter_utils.ThisThreadGenerator ( self.batch_func, (samples_host.create_cli(), index2d_host.create_cli(),) )] else: self.generators_count = np.clip(multiprocessing.cpu_count(), 2, 4) self.generators = [iter_utils.SubprocessGenerator ( self.batch_func, (samples_host.create_cli(), index2d_host.create_cli(),), start_now=True ) for i in range(self.generators_count) ] self.generator_counter = -1
def __init__(self, samples_path, debug, batch_size, temporal_image_count, sample_process_options=SampleProcessor.Options(), output_sample_types=[], generators_count=2, **kwargs): super().__init__(samples_path, debug, batch_size) self.temporal_image_count = temporal_image_count self.sample_process_options = sample_process_options self.output_sample_types = output_sample_types self.samples = SampleLoader.load(SampleType.FACE_TEMPORAL_SORTED, self.samples_path) if self.debug: self.generators_count = 1 self.generators = [ iter_utils.ThisThreadGenerator(self.batch_func, 0) ] else: self.generators_count = min(generators_count, len(self.samples)) self.generators = [ iter_utils.SubprocessGenerator(self.batch_func, i) for i in range(self.generators_count) ] self.generator_counter = -1
def batch_func(self, param ): samples, index_host, ct_samples, ct_index_host = param bs = self.batch_size while True: batches = None indexes = index_host.multi_get(bs) ct_indexes = ct_index_host.multi_get(bs) if ct_samples is not None else None t = time.time() for n_batch in range(bs): sample_idx = indexes[n_batch] sample = samples[sample_idx] ct_sample = None if ct_samples is not None: ct_sample = ct_samples[ct_indexes[n_batch]] try: x, = SampleProcessor.process ([sample], self.sample_process_options, self.output_sample_types, self.debug, ct_sample=ct_sample) except: raise Exception ("Exception occured in sample %s. Error: %s" % (sample.filename, traceback.format_exc() ) ) if batches is None: batches = [ [] for _ in range(len(x)) ] for i in range(len(x)): batches[i].append ( x[i] ) yield [ np.array(batch) for batch in batches]
def __init__(self, samples_path, debug=False, batch_size=1, random_ct_samples_path=None, sample_process_options=SampleProcessor.Options(), output_sample_types=[], add_sample_idx=False, generators_count=4, raise_on_no_data=True, **kwargs): super().__init__(debug, batch_size) self.sample_process_options = sample_process_options self.output_sample_types = output_sample_types self.add_sample_idx = add_sample_idx if self.debug: self.generators_count = 1 else: self.generators_count = max(1, generators_count) samples = SampleLoader.load(SampleType.FACE, samples_path) self.samples_len = len(samples) self.initialized = False if self.samples_len == 0: if raise_on_no_data: raise ValueError('No training data provided.') else: return index_host = mplib.IndexHost(self.samples_len) if random_ct_samples_path is not None: ct_samples = SampleLoader.load(SampleType.FACE, random_ct_samples_path) ct_index_host = mplib.IndexHost(len(ct_samples)) else: ct_samples = None ct_index_host = None if self.debug: self.generators = [ ThisThreadGenerator(self.batch_func, (samples, index_host.create_cli(), ct_samples, ct_index_host.create_cli() if ct_index_host is not None else None)) ] else: self.generators = [SubprocessGenerator ( self.batch_func, (samples, index_host.create_cli(), ct_samples, ct_index_host.create_cli() if ct_index_host is not None else None), start_now=False ) \ for i in range(self.generators_count) ] SubprocessGenerator.start_in_parallel(self.generators) self.generator_counter = -1 self.initialized = True
def __init__(self, samples_path, debug, batch_size, sort_by_yaw=False, sort_by_yaw_target_samples_path=None, random_ct_samples_path=None, sample_process_options=SampleProcessor.Options(), output_sample_types=[], add_sample_idx=False, generators_count=2, generators_random_seed=None, **kwargs): super().__init__(samples_path, debug, batch_size) self.sample_process_options = sample_process_options self.output_sample_types = output_sample_types self.add_sample_idx = add_sample_idx if sort_by_yaw_target_samples_path is not None: self.sample_type = SampleType.FACE_YAW_SORTED_AS_TARGET elif sort_by_yaw: self.sample_type = SampleType.FACE_YAW_SORTED else: self.sample_type = SampleType.FACE if generators_random_seed is not None and len( generators_random_seed) != generators_count: raise ValueError("len(generators_random_seed) != generators_count") self.generators_random_seed = generators_random_seed samples = SampleLoader.load(self.sample_type, self.samples_path, sort_by_yaw_target_samples_path) ct_samples = SampleLoader.load( SampleType.FACE, random_ct_samples_path ) if random_ct_samples_path is not None else None self.random_ct_sample_chance = 100 if self.debug: self.generators_count = 1 self.generators = [ iter_utils.ThisThreadGenerator(self.batch_func, (0, samples, ct_samples)) ] else: self.generators_count = min(generators_count, len(samples)) self.generators = [ iter_utils.SubprocessGenerator( self.batch_func, (i, samples[i::self.generators_count], ct_samples)) for i in range(self.generators_count) ] self.generator_counter = -1
def __init__(self, samples_path, debug=False, batch_size=1, random_ct_samples_path=None, sample_process_options=SampleProcessor.Options(), output_sample_types=[], add_sample_idx=False, generators_count=4, rnd_seed=None, **kwargs): super().__init__(debug, batch_size) self.sample_process_options = sample_process_options self.output_sample_types = output_sample_types self.add_sample_idx = add_sample_idx if rnd_seed is None: rnd_seed = np.random.randint(0x80000000) if self.debug: self.generators_count = 1 else: self.generators_count = max(1, generators_count) samples = SampleLoader.load(SampleType.FACE, samples_path) self.samples_len = len(samples) if self.samples_len == 0: raise ValueError('No training data provided.') if random_ct_samples_path is not None: ct_samples = SampleLoader.load(SampleType.FACE, random_ct_samples_path) else: ct_samples = None pickled_samples = pickle.dumps(samples, 4) ct_pickled_samples = pickle.dumps( ct_samples, 4) if ct_samples is not None else None if self.debug: self.generators = [ ThisThreadGenerator( self.batch_func, (pickled_samples, ct_pickled_samples, rnd_seed)) ] else: self.generators = [SubprocessGenerator ( self.batch_func, (pickled_samples, ct_pickled_samples, rnd_seed+i), start_now=False ) \ for i in range(self.generators_count) ] SubprocessGenerator.start_in_parallel(self.generators) self.generator_counter = -1
def __init__(self, samples_path, debug, batch_size, sort_by_yaw=False, sort_by_yaw_target_samples_path=None, sample_process_options=SampleProcessor.Options(), output_sample_types=[], add_sample_idx=False, add_pitch=False, add_yaw=False, generators_count=2, generators_random_seed=None, **kwargs): super().__init__(samples_path, debug, batch_size) self.sample_process_options = sample_process_options self.output_sample_types = output_sample_types self.add_sample_idx = add_sample_idx self.add_pitch = add_pitch self.add_yaw = add_yaw if sort_by_yaw_target_samples_path is not None: self.sample_type = SampleType.FACE_YAW_SORTED_AS_TARGET elif sort_by_yaw: self.sample_type = SampleType.FACE_YAW_SORTED else: self.sample_type = SampleType.FACE self.samples = SampleLoader.load(self.sample_type, self.samples_path, sort_by_yaw_target_samples_path) if generators_random_seed is not None and len( generators_random_seed) != generators_count: raise ValueError("len(generators_random_seed) != generators_count") self.generators_random_seed = generators_random_seed if self.debug: self.generators_count = 1 self.generators = [ iter_utils.ThisThreadGenerator(self.batch_func, 0) ] else: self.generators_count = min(generators_count, len(self.samples)) self.generators = [ iter_utils.SubprocessGenerator(self.batch_func, i) for i in range(self.generators_count) ] self.generators_sq = [ multiprocessing.Queue() for _ in range(self.generators_count) ] self.generator_counter = -1
def __init__(self, samples_path, debug=False, batch_size=1, random_ct_samples_path=None, sample_process_options=SampleProcessor.Options(), output_sample_types=[], add_sample_idx=False, **kwargs): super().__init__(samples_path, debug, batch_size) self.sample_process_options = sample_process_options self.output_sample_types = output_sample_types self.add_sample_idx = add_sample_idx samples_host = SampleHost.mp_host(SampleType.FACE, self.samples_path) self.samples_len = len(samples_host) if self.samples_len == 0: raise ValueError('No training data provided.') index_host = mp_utils.IndexHost(self.samples_len) if random_ct_samples_path is not None: ct_samples_host = SampleHost.mp_host(SampleType.FACE, random_ct_samples_path) ct_index_host = mp_utils.IndexHost(len(ct_samples_host)) else: ct_samples_host = None ct_index_host = None if self.debug: self.generators_count = 1 self.generators = [ iter_utils.ThisThreadGenerator( self.batch_func, (samples_host.create_cli(), index_host.create_cli(), ct_samples_host.create_cli() if ct_index_host is not None else None, ct_index_host.create_cli() if ct_index_host is not None else None)) ] else: self.generators_count = np.clip(multiprocessing.cpu_count(), 2, 4) self.generators = [ iter_utils.SubprocessGenerator( self.batch_func, (samples_host.create_cli(), index_host.create_cli(), ct_samples_host.create_cli() if ct_index_host is not None else None, ct_index_host.create_cli() if ct_index_host is not None else None), start_now=True) for i in range(self.generators_count) ] self.generator_counter = -1
def batch_func(self, generator_id): samples = self.samples samples_len = len(samples) if samples_len == 0: raise ValueError('No training data provided.') mult_max = 1 l = samples_len - ((self.temporal_image_count) * mult_max - (mult_max - 1)) samples_idxs = [*range(l + 1)][generator_id::self.generators_count] if len(samples_idxs) - self.temporal_image_count < 0: raise ValueError('Not enough samples to fit temporal line.') shuffle_idxs = [] while True: batches = None for _ in range(self.batch_size): if not shuffle_idxs: shuffle_idxs = samples_idxs.copy() np.random.shuffle(shuffle_idxs) idx = shuffle_idxs.pop() temporal_samples = [] mult = np.random.randint(mult_max) + 1 for i in range(self.temporal_image_count): sample = samples[idx + i * mult] try: temporal_samples += SampleProcessor.process( sample, self.sample_process_options, self.output_sample_types, self.debug) except: raise Exception( "Exception occured in sample %s. Error: %s" % (sample.filename, traceback.format_exc())) if batches is None: batches = [[] for _ in range(len(temporal_samples))] for i in range(len(temporal_samples)): batches[i].append(temporal_samples[i]) yield [np.array(batch) for batch in batches]
def batch_func(self, generator_id): samples = self.generator_samples[generator_id] samples_len = len(samples) if samples_len == 0: raise ValueError('No training data provided.') if samples_len - self.temporal_image_count < 0: raise ValueError('Not enough samples to fit temporal line.') shuffle_idxs = [] samples_sub_len = samples_len - self.temporal_image_count + 1 while True: batches = None for n_batch in range(self.batch_size): if len(shuffle_idxs) == 0: shuffle_idxs = [*range(samples_sub_len)] np.random.shuffle(shuffle_idxs) idx = shuffle_idxs.pop() temporal_samples = [] for i in range(self.temporal_image_count): sample = samples[idx + i] try: temporal_samples += SampleProcessor.process( sample, self.sample_process_options, self.output_sample_types, self.debug) except: raise Exception( "Exception occured in sample %s. Error: %s" % (sample.filename, traceback.format_exc())) if batches is None: batches = [[] for _ in range(len(temporal_samples))] for i in range(len(temporal_samples)): batches[i].append(temporal_samples[i]) yield [np.array(batch) for batch in batches]
def __init__(self, samples_path, debug, batch_size, temporal_image_count, sample_process_options=SampleProcessor.Options(), output_sample_types=[], **kwargs): super().__init__(debug, batch_size) self.temporal_image_count = temporal_image_count self.sample_process_options = sample_process_options self.output_sample_types = output_sample_types self.samples = SampleLoader.load(SampleType.IMAGE, samples_path) self.generator_samples = [self.samples] self.generators = [iter_utils.ThisThreadGenerator ( self.batch_func, 0 )] if self.debug else \ [iter_utils.SubprocessGenerator ( self.batch_func, 0 )] self.generator_counter = -1
def __init__(self, samples_path, debug, batch_size, temporal_image_count, sample_process_options=SampleProcessor.Options(), output_sample_types=[], generators_count=2, **kwargs): super().__init__(samples_path, debug, batch_size) self.temporal_image_count = temporal_image_count self.sample_process_options = sample_process_options self.output_sample_types = output_sample_types if self.debug: self.generators_count = 1 else: self.generators_count = generators_count samples = SampleHost.load(SampleType.FACE_TEMPORAL_SORTED, self.samples_path) samples_len = len(samples) if samples_len == 0: raise ValueError('No training data provided.') pickled_samples = pickle.dumps(samples, 4) if self.debug: self.generators = [ iter_utils.ThisThreadGenerator(self.batch_func, (0, pickled_samples)) ] else: self.generators = [ iter_utils.SubprocessGenerator(self.batch_func, (i, pickled_samples)) for i in range(self.generators_count) ] self.generator_counter = -1
def __init__(self, samples_path, debug, batch_size, resolution, sample_process_options=SampleProcessor.Options(), **kwargs): super().__init__(samples_path, debug, batch_size) self.sample_process_options = sample_process_options self.resolution = resolution self.samples = SampleLoader.load( SampleType.FACE_WITH_NEAREST_AS_TARGET, self.samples_path, self.samples_path) if self.debug: self.generator_samples = [self.samples] self.generators = [ iter_utils.ThisThreadGenerator(self.batch_func, 0) ] else: if len(self.samples) > 1: self.generator_samples = [ self.samples[0::2], self.samples[1::2] ] self.generators = [ iter_utils.SubprocessGenerator(self.batch_func, 0), iter_utils.SubprocessGenerator(self.batch_func, 1) ] else: self.generator_samples = [self.samples] self.generators = [ iter_utils.SubprocessGenerator(self.batch_func, 0) ] self.generator_counter = -1
def batch_func(self, param): pickled_samples, ct_pickled_samples, rnd_seed = param rnd_state = np.random.RandomState(rnd_seed) samples = pickle.loads(pickled_samples) idxs = [*range(len(samples))] shuffle_idxs = [] if ct_pickled_samples is not None: ct_samples = pickle.loads(ct_pickled_samples) ct_idxs = [*range(len(ct_samples))] ct_shuffle_idxs = [] else: ct_samples = None bs = self.batch_size while True: batches = None for n_batch in range(bs): if len(shuffle_idxs) == 0: shuffle_idxs = idxs.copy() rnd_state.shuffle(shuffle_idxs) sample_idx = shuffle_idxs.pop() sample = samples[sample_idx] ct_sample = None if ct_samples is not None: if len(ct_shuffle_idxs) == 0: ct_shuffle_idxs = ct_idxs.copy() rnd_state.shuffle(ct_shuffle_idxs) ct_sample_idx = ct_shuffle_idxs.pop() ct_sample = ct_samples[ct_sample_idx] try: x, = SampleProcessor.process([sample], self.sample_process_options, self.output_sample_types, self.debug, ct_sample=ct_sample, rnd_state=rnd_state) except: raise Exception( "Exception occured in sample %s. Error: %s" % (sample.filename, traceback.format_exc())) if batches is None: batches = [[] for _ in range(len(x))] if self.add_sample_idx: batches += [[]] i_sample_idx = len(batches) - 1 for i in range(len(x)): batches[i].append(x[i]) if self.add_sample_idx: batches[i_sample_idx].append(sample_idx) yield [np.array(batch) for batch in batches]
def batch_func(self, param): generator_id, samples, ct_samples = param if self.generators_random_seed is not None: np.random.seed(self.generators_random_seed[generator_id]) samples_len = len(samples) samples_idxs = [*range(samples_len)] ct_samples_len = len(ct_samples) if ct_samples is not None else 0 if len(samples_idxs) == 0: raise ValueError('No training data provided.') if self.sample_type == SampleType.FACE_YAW_SORTED or self.sample_type == SampleType.FACE_YAW_SORTED_AS_TARGET: if all([samples[idx] == None for idx in samples_idxs]): raise ValueError( 'Not enough training data. Gather more faces!') if self.sample_type == SampleType.FACE: shuffle_idxs = [] elif self.sample_type == SampleType.FACE_YAW_SORTED or self.sample_type == SampleType.FACE_YAW_SORTED_AS_TARGET: shuffle_idxs = [] shuffle_idxs_2D = [[]] * samples_len while True: batches = None for n_batch in range(self.batch_size): while True: sample = None if self.sample_type == SampleType.FACE: if len(shuffle_idxs) == 0: shuffle_idxs = samples_idxs.copy() np.random.shuffle(shuffle_idxs) idx = shuffle_idxs.pop() sample = samples[idx] elif self.sample_type == SampleType.FACE_YAW_SORTED or self.sample_type == SampleType.FACE_YAW_SORTED_AS_TARGET: if len(shuffle_idxs) == 0: shuffle_idxs = samples_idxs.copy() np.random.shuffle(shuffle_idxs) idx = shuffle_idxs.pop() if samples[idx] != None: if len(shuffle_idxs_2D[idx]) == 0: a = shuffle_idxs_2D[idx] = [ *range(len(samples[idx])) ] np.random.shuffle(a) idx2 = shuffle_idxs_2D[idx].pop() sample = samples[idx][idx2] idx = (idx << 16) | (idx2 & 0xFFFF) if sample is not None: try: x = SampleProcessor.process( sample, self.sample_process_options, self.output_sample_types, self.debug, ct_sample=ct_samples[np.random.randint( ct_samples_len)] if ct_samples is not None else None) except: raise Exception( "Exception occured in sample %s. Error: %s" % (sample.filename, traceback.format_exc())) if type(x) != tuple and type(x) != list: raise Exception( 'SampleProcessor.process returns NOT tuple/list' ) if batches is None: batches = [[] for _ in range(len(x))] if self.add_sample_idx: batches += [[]] i_sample_idx = len(batches) - 1 for i in range(len(x)): batches[i].append(x[i]) if self.add_sample_idx: batches[i_sample_idx].append(idx) break yield [np.array(batch) for batch in batches]
def batch_func(self, generator_id): gen_sq = self.generators_sq[generator_id] if self.generators_random_seed is not None: np.random.seed(self.generators_random_seed[generator_id]) samples = self.samples samples_len = len(samples) samples_idxs = [*range(samples_len) ][generator_id::self.generators_count] repeat_samples_idxs = [] if len(samples_idxs) == 0: raise ValueError('No training data provided.') if self.sample_type == SampleType.FACE_YAW_SORTED or self.sample_type == SampleType.FACE_YAW_SORTED_AS_TARGET: if all([samples[idx] == None for idx in samples_idxs]): raise ValueError( 'Not enough training data. Gather more faces!') if self.sample_type == SampleType.FACE: shuffle_idxs = [] elif self.sample_type == SampleType.FACE_YAW_SORTED or self.sample_type == SampleType.FACE_YAW_SORTED_AS_TARGET: shuffle_idxs = [] shuffle_idxs_2D = [[]] * samples_len while True: while not gen_sq.empty(): idxs = gen_sq.get() for idx in idxs: if idx in samples_idxs: repeat_samples_idxs.append(idx) batches = None for n_batch in range(self.batch_size): while True: sample = None if len(repeat_samples_idxs) > 0: idx = repeat_samples_idxs.pop() if self.sample_type == SampleType.FACE: sample = samples[idx] elif self.sample_type == SampleType.FACE_YAW_SORTED or self.sample_type == SampleType.FACE_YAW_SORTED_AS_TARGET: sample = samples[(idx >> 16) & 0xFFFF][idx & 0xFFFF] else: if self.sample_type == SampleType.FACE: if len(shuffle_idxs) == 0: shuffle_idxs = samples_idxs.copy() np.random.shuffle(shuffle_idxs) idx = shuffle_idxs.pop() sample = samples[idx] elif self.sample_type == SampleType.FACE_YAW_SORTED or self.sample_type == SampleType.FACE_YAW_SORTED_AS_TARGET: if len(shuffle_idxs) == 0: shuffle_idxs = samples_idxs.copy() np.random.shuffle(shuffle_idxs) idx = shuffle_idxs.pop() if samples[idx] != None: if len(shuffle_idxs_2D[idx]) == 0: a = shuffle_idxs_2D[idx] = [ *range(len(samples[idx])) ] np.random.shuffle(a) idx2 = shuffle_idxs_2D[idx].pop() sample = samples[idx][idx2] idx = (idx << 16) | (idx2 & 0xFFFF) if sample is not None: try: x = SampleProcessor.process( sample, self.sample_process_options, self.output_sample_types, self.debug) except: raise Exception( "Exception occured in sample %s. Error: %s" % (sample.filename, traceback.format_exc())) if type(x) != tuple and type(x) != list: raise Exception( 'SampleProcessor.process returns NOT tuple/list' ) if batches is None: batches = [[] for _ in range(len(x))] if self.add_sample_idx: batches += [[]] i_sample_idx = len(batches) - 1 if self.add_pitch: batches += [[]] i_pitch = len(batches) - 1 if self.add_yaw: batches += [[]] i_yaw = len(batches) - 1 for i in range(len(x)): batches[i].append(x[i]) if self.add_sample_idx: batches[i_sample_idx].append(idx) if self.add_pitch or self.add_yaw: pitch, yaw = LandmarksProcessor.estimate_pitch_yaw( sample.landmarks) if self.add_pitch: batches[i_pitch].append([pitch]) if self.add_yaw: batches[i_yaw].append([yaw]) break yield [np.array(batch) for batch in batches]
def batch_func(self, generator_id): samples = self.generator_samples[generator_id] data_len = len(samples) if data_len == 0: raise ValueError('No training data provided.') shuffle_idxs = [] output_sample_types = [ [f.WARPED_TRANSFORMED | face_type | f.MODE_BGR, self.resolution], [f.TRANSFORMED | face_type | f.MODE_BGR, self.resolution], [ f.TRANSFORMED | face_type | f.MODE_M | f.FACE_MASK_FULL, self.resolution ] ] while True: batches = None for n_batch in range(self.batch_size): while True: if len(shuffle_idxs) == 0: shuffle_idxs = [*range(data_len)] np.random.shuffle(shuffle_idxs) idx = shuffle_idxs.pop() sample = samples[idx] nearest_sample = sample.nearest_target_list[ np.random.randint(1, len(sample.nearest_target_list))] try: x = SampleProcessor.process( sample, self.sample_process_options, output_sample_types, self.debug) except: raise Exception( "Exception occured in sample %s. Error: %s" % (sample.filename, traceback.format_exc())) try: x2 = SampleProcessor.process( nearest_sample, self.sample_process_options, output_sample_types, self.debug) except: raise Exception( "Exception occured in sample %s. Error: %s" % (nearest_sample.filename, traceback.format_exc())) if batches is None: batches = [[] for _ in range(6)] batches[0].append(x[0]) batches[1].append(x[1]) batches[2].append(x[2]) batches[3].append(x2[0]) batches[4].append(x2[1]) batches[5].append(x2[2]) res = sample.shape[0] s_landmarks = sample.landmarks.copy() d_landmarks = nearest_sample.landmarks.copy() idxs = list(range(len(s_landmarks))) for i in idxs[:]: s_l = s_landmarks[i] d_l = d_landmarks[i] if s_l[0] < 5 or s_l[1] < 5 or s_l[0] >= res-5 or s_l[1] >= res-5 or \ d_l[0] < 5 or d_l[1] < 5 or d_l[0] >= res-5 or d_l[1] >= res-5: idxs.remove(i) for landmarks in [s_landmarks, d_landmarks]: for i in idxs[:]: s_l = landmarks[i] for j in idxs[:]: if i == j: continue s_l_2 = landmarks[j] diff_l = np.abs(s_l - s_l_2) if np.sqrt(diff_l.dot(diff_l)) < 5: idxs.remove(i) break s_landmarks = s_landmarks[idxs] d_landmarks = d_landmarks[idxs] s_landmarks = np.concatenate([ s_landmarks, [[0, 0], [res // 2, 0], [res - 1, 0], [0, res // 2], [res - 1, res // 2], [0, res - 1], [res // 2, res - 1], [res - 1, res - 1]] ]) d_landmarks = np.concatenate([ d_landmarks, [[0, 0], [res // 2, 0], [res - 1, 0], [0, res // 2], [res - 1, res // 2], [0, res - 1], [res // 2, res - 1], [res - 1, res - 1]] ]) x_len = len(x) for i in range(x_len): x[i] = imagelib.morph_by_points( x[i], s_landmarks, d_landmarks) x2[i] = imagelib.morph_by_points( x2[i], d_landmarks, s_landmarks) batches[i].append(x[i]) batches[i + x_len].append(x2[i]) break yield [np.array(batch) for batch in batches]
def __init__ (self, samples_path, debug=False, batch_size=1, random_ct_samples_path=None, sample_process_options=SampleProcessor.Options(), output_sample_types=[], uniform_yaw_distribution=False, generators_count=4, raise_on_no_data=True, **kwargs): super().__init__(debug, batch_size) self.initialized = False self.sample_process_options = sample_process_options self.output_sample_types = output_sample_types if self.debug: self.generators_count = 1 else: self.generators_count = max(1, generators_count) samples = SampleLoader.load (SampleType.FACE, samples_path) self.samples_len = len(samples) if self.samples_len == 0: if raise_on_no_data: raise ValueError('No training data provided.') else: return if uniform_yaw_distribution: samples_pyr = [ ( idx, sample.get_pitch_yaw_roll() ) for idx, sample in enumerate(samples) ] grads = 128 #instead of math.pi / 2, using -1.2,+1.2 because actually maximum yaw for 2DFAN landmarks are -1.2+1.2 grads_space = np.linspace (-1.2, 1.2,grads) yaws_sample_list = [None]*grads for g in io.progress_bar_generator ( range(grads), "Sort by yaw"): yaw = grads_space[g] next_yaw = grads_space[g+1] if g < grads-1 else yaw yaw_samples = [] for idx, pyr in samples_pyr: s_yaw = -pyr[1] if (g == 0 and s_yaw < next_yaw) or \ (g < grads-1 and s_yaw >= yaw and s_yaw < next_yaw) or \ (g == grads-1 and s_yaw >= yaw): yaw_samples += [ idx ] if len(yaw_samples) > 0: yaws_sample_list[g] = yaw_samples yaws_sample_list = [ y for y in yaws_sample_list if y is not None ] index_host = mplib.Index2DHost( yaws_sample_list ) else: index_host = mplib.IndexHost(self.samples_len) if random_ct_samples_path is not None: ct_samples = SampleLoader.load (SampleType.FACE, random_ct_samples_path) ct_index_host = mplib.IndexHost( len(ct_samples) ) else: ct_samples = None ct_index_host = None if self.debug: self.generators = [ThisThreadGenerator ( self.batch_func, (samples, index_host.create_cli(), ct_samples, ct_index_host.create_cli() if ct_index_host is not None else None) )] else: self.generators = [SubprocessGenerator ( self.batch_func, (samples, index_host.create_cli(), ct_samples, ct_index_host.create_cli() if ct_index_host is not None else None), start_now=False ) \ for i in range(self.generators_count) ] SubprocessGenerator.start_in_parallel( self.generators ) self.generator_counter = -1 self.initialized = True
def __init__ (self, samples_path, debug=False, batch_size=1, sample_process_options=SampleProcessor.Options(), output_sample_types=[], person_id_mode=1, use_caching=False, generators_count=2, generators_random_seed=None, **kwargs): super().__init__(samples_path, debug, batch_size) self.sample_process_options = sample_process_options self.output_sample_types = output_sample_types self.person_id_mode = person_id_mode if generators_random_seed is not None and len(generators_random_seed) != generators_count: raise ValueError("len(generators_random_seed) != generators_count") self.generators_random_seed = generators_random_seed samples = SampleHost.load (SampleType.FACE, self.samples_path, person_id_mode=True, use_caching=use_caching) samples = copy.copy(samples) for i in range(len(samples)): samples[i] = copy.copy(samples[i]) if person_id_mode==1: #np.random.shuffle(samples) # #new_samples = [] #while len(samples) > 0: # for i in range( len(samples)-1, -1, -1): # sample = samples[i] # # if len(sample) > 0: # new_samples.append(sample.pop(0)) # # if len(sample) == 0: # samples.pop(i) # i -= 1 #samples = new_samples new_samples = [] for s in samples: new_samples += s samples = new_samples np.random.shuffle(samples) self.samples_len = len(samples) if self.samples_len == 0: raise ValueError('No training data provided.') if self.debug: self.generators_count = 1 self.generators = [iter_utils.ThisThreadGenerator ( self.batch_func, (0, samples) )] else: self.generators_count = min ( generators_count, self.samples_len ) if person_id_mode==1: self.generators = [iter_utils.SubprocessGenerator ( self.batch_func, (i, samples[i::self.generators_count]) ) for i in range(self.generators_count) ] else: self.generators = [iter_utils.SubprocessGenerator ( self.batch_func, (i, samples) ) for i in range(self.generators_count) ] self.generator_counter = -1
def batch_func(self, param): generator_id, samples = param if self.generators_random_seed is not None: np.random.seed(self.generators_random_seed[generator_id]) if self.person_id_mode == 1: samples_len = len(samples) samples_idxs = [*range(samples_len)] shuffle_idxs = [] elif self.person_id_mode == 2: persons_count = len(samples) person_idxs = [] for j in range(persons_count): for i in range(j + 1, persons_count): person_idxs += [[i, j]] shuffle_person_idxs = [] samples_idxs = [None] * persons_count shuffle_idxs = [None] * persons_count for i in range(persons_count): samples_idxs[i] = [*range(len(samples[i]))] shuffle_idxs[i] = [] while True: if self.person_id_mode == 2: if len(shuffle_person_idxs) == 0: shuffle_person_idxs = person_idxs.copy() np.random.shuffle(shuffle_person_idxs) person_ids = shuffle_person_idxs.pop() batches = None for n_batch in range(self.batch_size): if self.person_id_mode == 1: if len(shuffle_idxs) == 0: shuffle_idxs = samples_idxs.copy() #np.random.shuffle(shuffle_idxs) idx = shuffle_idxs.pop() sample = samples[idx] try: x = SampleProcessor.process( sample, self.sample_process_options, self.output_sample_types, self.debug) except: raise Exception( "Exception occured in sample %s. Error: %s" % (sample.filename, traceback.format_exc())) if type(x) != tuple and type(x) != list: raise Exception( 'SampleProcessor.process returns NOT tuple/list') if batches is None: batches = [[] for _ in range(len(x))] batches += [[]] i_person_id = len(batches) - 1 for i in range(len(x)): batches[i].append(x[i]) batches[i_person_id].append(np.array([sample.person_id])) else: person_id1, person_id2 = person_ids if len(shuffle_idxs[person_id1]) == 0: shuffle_idxs[person_id1] = samples_idxs[ person_id1].copy() np.random.shuffle(shuffle_idxs[person_id1]) idx = shuffle_idxs[person_id1].pop() sample1 = samples[person_id1][idx] if len(shuffle_idxs[person_id2]) == 0: shuffle_idxs[person_id2] = samples_idxs[ person_id2].copy() np.random.shuffle(shuffle_idxs[person_id2]) idx = shuffle_idxs[person_id2].pop() sample2 = samples[person_id2][idx] if sample1 is not None and sample2 is not None: try: x1 = SampleProcessor.process( sample1, self.sample_process_options, self.output_sample_types, self.debug) except: raise Exception( "Exception occured in sample %s. Error: %s" % (sample1.filename, traceback.format_exc())) try: x2 = SampleProcessor.process( sample2, self.sample_process_options, self.output_sample_types, self.debug) except: raise Exception( "Exception occured in sample %s. Error: %s" % (sample2.filename, traceback.format_exc())) x1_len = len(x1) if batches is None: batches = [[] for _ in range(x1_len)] batches += [[]] i_person_id1 = len(batches) - 1 batches += [[] for _ in range(len(x2))] batches += [[]] i_person_id2 = len(batches) - 1 for i in range(x1_len): batches[i].append(x1[i]) for i in range(len(x2)): batches[x1_len + 1 + i].append(x2[i]) batches[i_person_id1].append( np.array([sample1.person_id])) batches[i_person_id2].append( np.array([sample2.person_id])) yield [np.array(batch) for batch in batches]