Ejemplo n.º 1
0
def G1DListMutatorRealRange(genome, **args):
    """ Simple real range mutator for G1DList

   Accepts the *rangemin* and *rangemax* genome parameters, both optional.

   """
    from . import Consts

    if args["pmut"] <= 0.0:
        return 0
    listSize = len(genome)
    mutations = args["pmut"] * (listSize)

    if mutations < 1.0:
        mutations = 0
        for it in range(listSize):
            if Util.randomFlipCoin(args["pmut"]):
                genome[it] = rand_uniform(
                    genome.getParam("rangemin", Consts.CDefRangeMin),
                    genome.getParam("rangemax", Consts.CDefRangeMax))
                mutations += 1

    else:
        for it in range(int(round(mutations))):
            which_gene = rand_randint(0, listSize - 1)
            genome[which_gene] = rand_uniform(
                genome.getParam("rangemin", Consts.CDefRangeMin),
                genome.getParam("rangemax", Consts.CDefRangeMax))

    return int(mutations)
Ejemplo n.º 2
0
def PacmanFixStartInitializator(genome, **args):
    chromoawesome = [30.0, 1.0, -175.0, 0.8, 20.0, 0.5, -5, 0.5, 40.0, 0.8, 100.0, 0.3, 0.0, 0.01, 0.0, 0.8, 500.0, 0.8, -1.0, 0.5, 0.0, 0.0001, 0.8]
    
    result = []
    for i in range(0, CHROMOSOME_LENGTH):
        if i % 2 != 0:
            ch = abs(chromoawesome[i])
            final_value = chromoawesome[i] + rand_uniform(-ch / 10.0, ch / 10.0)
            final_value = max(final_value, genome.getParam("minSigma"))
            final_value = min(final_value, genome.getParam("maxSigma"))
        
            result.append(final_value)
        elif i < CHROMOSOME_LENGTH - 1:
            ch = abs(chromoawesome[i])
            final_value = chromoawesome[i] + rand_uniform(-ch / 10.0, ch / 10.0)
            final_value = max(final_value, genome.getParam("minMean"))
            final_value = min(final_value, genome.getParam("maxMean"))
        
            result.append(final_value)
        else:
            ch = abs(chromoawesome[i])
            final_value = chromoawesome[i] + rand_uniform(-ch / 10.0, ch / 10.0)
            final_value = max(final_value, genome.getParam("minWallPenalty"))
            final_value = min(final_value, genome.getParam("maxWallPenalty"))
        
            result.append(final_value)

    genome.genomeList = result        
Ejemplo n.º 3
0
def G1DListMutatorRealRange(genome, **args):
   """ Simple real range mutator for G1DList

   Accepts the *rangemin* and *rangemax* genome parameters, both optional.

   """
   if args["pmut"] <= 0.0:
      return 0
   listSize = len(genome)
   mutations = args["pmut"] * (listSize)

   if mutations < 1.0:
      mutations = 0
      for it in xrange(listSize):
         if Util.randomFlipCoin(args["pmut"]):
            genome[it] = rand_uniform(genome.getParam("rangemin", Consts.CDefRangeMin),
                                      genome.getParam("rangemax", Consts.CDefRangeMax))
            mutations += 1

   else:
      for it in xrange(int(round(mutations))):
         which_gene = rand_randint(0, listSize - 1)
         genome[which_gene] = rand_uniform(genome.getParam("rangemin", Consts.CDefRangeMin),
                                           genome.getParam("rangemax", Consts.CDefRangeMax))

   return int(mutations)
Ejemplo n.º 4
0
def G1DConnInitializatorUniform(genome, **args):
    """ Real initialization function of G1DConnections
    
    This initializator accepts the *rangemin* and *rangemax* genome parameters.
    
    """
    range_min = genome.getParam("rangemin", -50)
    range_max = genome.getParam("rangemax", 50)
    layers = genome.getParam("layers", [2,4,1])
    bias = genome.getParam("bias", [1,1,0])

    ndLayers=np.array(layers)
    ndBias=np.array(bias)

    if genome.genomeList == []:
        totalConnections = int(np.sum([(layers[i]+1)*layers[i+1] for i in range(len(layers)-1)]))
        
        genomeList1=[]
    
        for ly in range(len(layers)-1):
            for toNeurode in range(layers[ly+1]):
                toNeurode += int(ndLayers[0:ly+1].sum()+ndBias[0:ly+1].sum())
                for fromNeurode in range(layers[ly]+1):
                    fromNeurode +=int(ndLayers[0:ly].sum()+ndBias[0:ly].sum())
                    genomeList1.append((fromNeurode, toNeurode, rand_uniform(range_min, range_max)))
    
        genome.genomeList = np.array(genomeList1, dtype=[('from','i'),('to','i'),('weight','f')])
    else:
        totalConnections = len(genome.genomeList)
        if totalConnections != genome.genomeSize:
            print "%% Warning: genome.genomeSize and the length of genome.genomeList mismatch!"
        for conn in genome.genomeList:
            conn[2] = rand_uniform(range_min, range_max)
Ejemplo n.º 5
0
def GTreeMutatorRealRange(genome, **args):
    """ The mutator of GTree, Real Range Mutator

   Accepts the *rangemin* and *rangemax* genome parameters, both optional.

   .. versionadded:: 0.6
      The *GTreeMutatorRealRange* function
   """
    from . import Consts

    if args["pmut"] <= 0.0:
        return 0
    elements = len(genome)
    mutations = args["pmut"] * elements

    range_min = genome.getParam("rangemin", Consts.CDefRangeMin)
    range_max = genome.getParam("rangemax", Consts.CDefRangeMax)

    if mutations < 1.0:
        mutations = 0
        for i in range(len(genome)):
            if Util.randomFlipCoin(args["pmut"]):
                mutations += 1
                rand_node = genome.getRandomNode()
                random_real = rand_uniform(range_min, range_max)
                rand_node.setData(random_real)

    else:
        for it in range(int(round(mutations))):
            rand_node = genome.getRandomNode()
            random_real = rand_uniform(range_min, range_max)
            rand_node.setData(random_real)

    return int(mutations)
Ejemplo n.º 6
0
def GTreeMutatorRealRange(genome, **args):
   """ The mutator of GTree, Real Range Mutator

   Accepts the *rangemin* and *rangemax* genome parameters, both optional.

   .. versionadded:: 0.6
      The *GTreeMutatorRealRange* function
   """
   if args["pmut"] <= 0.0:
      return 0
   elements = len(genome)
   mutations = args["pmut"] * elements

   range_min = genome.getParam("rangemin", Consts.CDefRangeMin)
   range_max = genome.getParam("rangemax", Consts.CDefRangeMax)

   if mutations < 1.0:
      mutations = 0
      for i in xrange(len(genome)):
         if Util.randomFlipCoin(args["pmut"]):
            mutations += 1
            rand_node = genome.getRandomNode()
            random_real = rand_uniform(range_min, range_max)
            rand_node.setData(random_real)

   else:
      for it in xrange(int(round(mutations))):
         rand_node = genome.getRandomNode()
         random_real = rand_uniform(range_min, range_max)
         rand_node.setData(random_real)

   return int(mutations)
Ejemplo n.º 7
0
def random_crop(image, boxes, labels):
    original_h = image.size(1)
    original_w = image.size(2)

    while True:
        min_overlap = rand_choice([0., .1, .3, .5, .7, .9, None])

        if min_overlap is None:
            return image, boxes, labels

        max_trials = 50
        for _ in range(max_trials):
            min_scale = 0.3
            scale_h = rand_uniform(min_scale, 1)
            scale_w = rand_uniform(min_scale, 1)
            new_h = int(scale_h * original_h)
            new_w = int(scale_w * original_w)

            aspect_ratio = new_h / new_w
            if not 0.5 < aspect_ratio < 2:
                continue

            left = randint(0, original_w - new_w)
            right = left + new_w
            top = randint(0, original_h - new_h)
            bottom = top + new_h
            crop = FloatTensor([left, top, right, bottom])

            overlap = find_jaccard_overlap(crop.unsqueeze(0), boxes)
            overlap = overlap.squeeze(0)

            if overlap.max().item() < min_overlap:
                continue

            new_image = image[:, top:bottom, left:right]

            bb_centers = (boxes[:, :2] + boxes[:, 2:]) / 2.

            centers_in_crop = (bb_centers[:, 0] > left) * (
                bb_centers[:, 0] < right) * (bb_centers[:, 1] >
                                             top) * (bb_centers[:, 1] < bottom)

            if not centers_in_crop.any():
                continue

            new_boxes = boxes[centers_in_crop, :]
            new_labels = labels[centers_in_crop]

            new_boxes[:, :2] = torch_max(new_boxes[:, :2], crop[:2])
            new_boxes[:, :2] -= crop[:2]
            new_boxes[:, 2:] = torch_min(new_boxes[:, 2:], crop[2:])
            new_boxes[:, 2:] -= crop[:2]

            return new_image, new_boxes, new_labels
Ejemplo n.º 8
0
def photometric_distort(image):
    new_image = image

    distortions = [
        adjust_brightness, adjust_contrast, adjust_saturation, adjust_hue
    ]
    rand_shuffle(distortions)

    for distortion in distortions:
        if rand_random() < 0.5:
            if distortion.__name__ is 'adjust_hue':
                adjust_factor = rand_uniform(-18 / 255., 18 / 255.)
            else:
                adjust_factor = rand_uniform(0.5, 1.5)

            new_image = distortion(new_image, adjust_factor)

    return new_image
Ejemplo n.º 9
0
def PacmanGaussianInitializator(genome, **args):
    listSize = genome.getListSize()
    
    minSigma = genome.getParam("minSigma")
    maxSigma = genome.getParam("maxSigma")
    minMean = genome.getParam("minMean")
    maxMean = genome.getParam("maxMean")
    minWallPenalty = genome.getParam("minWallPenalty")
    maxWallPenalty = genome.getParam("maxWallPenalty")
    
    result = []
    for i in range(0, listSize - 1):
        if i % 2 == 0:
            result.append(rand_uniform(minMean, maxMean))
        else:
            result.append(rand_uniform(minSigma, maxSigma))
    result.append(rand_uniform(minWallPenalty, maxWallPenalty))
    genome.genomeList = result        
Ejemplo n.º 10
0
def G1DListInitializatorReal(genome, **args):
    """ Real initialization function of G1DList

    This initializator accepts the *rangemin* and *rangemax* genome parameters.

    """
    range_min = genome.getParam("rangemin", 0)
    range_max = genome.getParam("rangemax", 100)

    genome.genomeList = [rand_uniform(range_min, range_max) for i in xrange(genome.getListSize())]
Ejemplo n.º 11
0
def G1DListInitializatorReal(genome, **args):
   """ Real initialization function of G1DList

   This initializator accepts the *rangemin* and *rangemax* genome parameters.

   """
   range_min = genome.getParam("rangemin", 0)
   range_max = genome.getParam("rangemax", 100)

   genome.genomeList = [rand_uniform(range_min, range_max) for i in xrange(genome.getListSize())]
Ejemplo n.º 12
0
def G1DListInitializatorReal(genome, **args):
	
	
   """ Real initialization function of G1DList

   This initializator accepts the *rangemin* and *rangemax* genome parameters.

   """
   length=genome.getParam("length", 2)
   r=genome.getParam("range_list", None)
   
   if r is None:
      
      range_min = genome.getParam("rangemin", 0)
      range_max = genome.getParam("rangemax", 100)

      genome.genomeList = [round(rand_uniform(range_min, range_max),length) for i in xrange(genome.getListSize())]
   else:

      genome.genomeList = [round(rand_uniform(r[i][0], r[i][1]),length) for i in xrange(genome.getListSize())]
Ejemplo n.º 13
0
def P1DVelListInitializatorReal(vector, **args):
    """ Real  velocity initialization function of Particle1D

   This initializator accepts the *rangemin* and *rangemax* vector parameters.

   """
    vector.clearList("velocity")

    for i in xrange(vector.dimmensionsSize):
        randomReal = rand_uniform(vector.getParam("rangeVelmin", 0),
                                  vector.getParam("rangeVelMax", 100))
        vector.append('velocity', randomReal)
Ejemplo n.º 14
0
def P1DPosListInitializatorReal(vector, **args):
    """ Real  position initialization function of Particle1D

   This initializator accepts the *rangemin* and *rangemax* vector parameters.

   """
    vector.clearList("position")

    for i in xrange(vector.dimmensionsSize):
        randomReal = rand_uniform(vector.getParam("rangePosmin", -100),
                                  vector.getParam("rangePosmax", 100))
        vector.append('position', randomReal)
Ejemplo n.º 15
0
def P1DPosListInitializatorReal(vector, **args):
   """ Real  position initialization function of Particle1D

   This initializator accepts the *rangemin* and *rangemax* vector parameters.

   """
   vector.clearList("position")

   for i in xrange(vector.dimmensionsSize):
      randomReal = rand_uniform(vector.getParam("rangePosmin", -100),
                                vector.getParam("rangePosmax", 100))
      vector.append('position',randomReal)
Ejemplo n.º 16
0
def P1DVelListInitializatorReal(vector, **args):
   """ Real  velocity initialization function of Particle1D

   This initializator accepts the *rangemin* and *rangemax* vector parameters.

   """
   vector.clearList("velocity")

   for i in xrange(vector.dimmensionsSize):
      randomReal = rand_uniform(vector.getParam("rangeVelmin", 0),
                                vector.getParam("rangeVelMax", 100))
      vector.append('velocity',randomReal)
Ejemplo n.º 17
0
def G1DListInitializatorReal(genome, **args):
   """ Real initialization function of G1DList

   This initializator accepts the *rangemin* and *rangemax* genome parameters.

   """
   genome.clearList()

   for i in xrange(genome.listSize):
      randomReal = rand_uniform(genome.getParam("rangemin", 0),
                                genome.getParam("rangemax", 100))
      genome.append(randomReal)
Ejemplo n.º 18
0
def write_midi_file(note_tracks, tempo_bpm, whole_note, time_sign=(4,4), file_name='new_piece.mid'):
    mfile = mido.MidiFile(ticks_per_beat=int(whole_note/4))
    ctrack = mido.MidiTrack()
    ctrack.append(mido.MetaMessage('track_name', name='control track'))
    ctrack.append(mido.MetaMessage('time_signature', numerator=int(time_sign[0]), denominator=int(time_sign[1])))
    ctrack.append(mido.MetaMessage('set_tempo', tempo=int(mido.bpm2tempo(tempo_bpm))))
    ctrack.append(mido.MetaMessage('end_of_track'))
    mfile.tracks.append(ctrack)
    for t in note_tracks:
        notes = note_tracks[t]
        track = mido.MidiTrack()
        track.append(mido.MetaMessage('track_name', name='track '+t))
        track.append(mido.Message('program_change'))
        for note_no, duration in zip(notes[:,0], notes[:,1]):
            if duration > 0:
                vel = [int(rand_uniform(65,127)), int(rand_uniform(65,127))]
                track.append(mido.Message('note_on',  note=int(note_no), velocity=vel[0], time=int(0)))
                track.append(mido.Message('note_off', note=int(note_no), velocity=vel[1], time=int(duration*whole_note)))
        track.append(mido.MetaMessage('end_of_track', time=int(0)))
        mfile.tracks.append(track)
    if not os.path.isfile(file_name): os.mknod(file_name)
    mfile.save(file_name)
Ejemplo n.º 19
0
def G2DListInitializatorReal(genome, **args):
   """ Integer initialization function of G2DList

   This initializator accepts the *rangemin* and *rangemax* genome parameters.

   """
   genome.clearList()
   
   for i in xrange(genome.getHeight()):
      for j in xrange(genome.getWidth()):
         randomReal = rand_uniform(genome.getParam("rangemin", 0),
                                   genome.getParam("rangemax", 100))
         genome.setItem(i, j, randomReal)
Ejemplo n.º 20
0
def G2DListInitializatorReal(genome, **args):
    """ Integer initialization function of G2DList

    This initializator accepts the *rangemin* and *rangemax* genome parameters.

    """
    genome.clearList()

    for i in xrange(genome.getHeight()):
        for j in xrange(genome.getWidth()):
            randomReal = rand_uniform(genome.getParam("rangemin", 0),
                                      genome.getParam("rangemax", 100))
            genome.setItem(i, j, randomReal)
Ejemplo n.º 21
0
def initializer(genome, **kwargs):
    params = {
        'world_size' : randint(1, 5),
        'population_size': randint(20, 100),
        'init_energy': rand_uniform(0.2, 1),
        'fight_transfer': rand_uniform(0, 1),
        'travel_threshold': rand_uniform(0, 1),
        'travel_cost': rand_uniform(0, 1),
        'reproduction_threshold': rand_uniform(0.3, 1),
        'death_threshold': rand_uniform(0.01, 0.4),
        'mutation_probability': rand_uniform(0.05, 0.5),
    }
    genome.conf.update(params)
Ejemplo n.º 22
0
def G1DConnUnbiasedMutateWeights(genome, **args):
	## args['mutation_conns'] takes the list of indices of connections to be mutated 
	if not args['mutation_conns']:
		mutation_conn_indices=rand_sample(numpy.arange(len(genome)),int(args['pmut']*len(genome)))
		#		print "Indices of mutation weights:"
		#		print mutation_conn_indices
	else:
		mutation_conn_indices = args['mutation_conns']
		#		print "Indices of mutation weights:"
		#		print mutation_conn_indices

	new_mutation_list=[]
	for it in mutation_conn_indices:
		new_mutation_list.append(rand_uniform(genome.getParam("rangemin", Consts.CDefRangeMin),genome.getParam("rangemax", Consts.CDefRangeMax)))

	numpy.put(genome['weight'],mutation_conn_indices,new_mutation_list)

	return genome
    def __init__(self, position, **kwargs):
        self.id_ = str(uuid.uuid1())

        self._get_config(kwargs)

        if self._respect_boundaries:
            self.MAX_POSITION = 1
            self.MIN_POSITION = 0

        self.position = position
        self._best_position = self.position.copy()
        self._best_fitness = float('-inf')
        self._velocity = numpy.array([
            rand_uniform(-self.MAX_VELOCITY, self.MAX_VELOCITY)
            for param in
            xrange(len(self.position))
        ])

        self._time = 0
Ejemplo n.º 24
0
    def applyFunctions(self, obj=None, **args):
        """ Generator to apply all function slots in obj

      :param obj: this object is passes as parameter to the function
      :param args: this args dictionary is passed to the function

      """
        if len(self.funcList) <= 0:
            Util.raiseException("No function defined: " + self.slotName)

        if not self.rand_apply:
            for f in self.funcList:
                yield f(obj, **args)
        else:
            v = rand_uniform(0, 1)
            fobj = None
            for func, weight in zip(self.funcList, self.funcWeights):
                fobj = func
                if v < weight:
                    break
                v = v - weight

            yield fobj(obj, **args)
Ejemplo n.º 25
0
   def applyFunctions(self, obj=None, **args):
       """ Generator to apply all function slots in obj
 
       :param obj: this object is passes as parameter to the function
       :param args: this args dictionary is passed to the function   
 
       """
       if len(self.funcList) <= 0:
           raise NotImplementedError("No function defined: " + self.slotName)
       
       if not self.rand_apply:
           for f in self.funcList:
              yield f(obj, **args)
       else:
           v = rand_uniform(0, 1)
           fobj = None
           for func, weight in zip(self.funcList, self.funcWeights):
              fobj = func
              if v < weight:
                 break
              v = v - weight
 
           yield fobj(obj, **args)
Ejemplo n.º 26
0
def mutator(genome, **kwargs):
    p = kwargs['pmut']
    mutations = 0

    if Util.randomFlipCoin(p):
        s = 0.1
        genome.conf['init_energy'] += rand_uniform(-s, s)
        mutations += 1

    if Util.randomFlipCoin(p):
        s = 0.1
        genome.conf['fight_transfer'] += rand_uniform(-s, s)
        mutations += 1

    if Util.randomFlipCoin(p):
        s = 0.1
        genome.conf['travel_threshold'] += rand_uniform(-s, s)
        mutations += 1

    if Util.randomFlipCoin(p):
        s = 0.1
        genome.conf['travel_cost'] += rand_uniform(-s, s)
        mutations += 1

    if Util.randomFlipCoin(p):
        s = 0.1
        genome.conf['reproduction_threshold'] += rand_uniform(-s, s)
        mutations += 1

    if Util.randomFlipCoin(p):
        s = 0.1
        genome.conf['death_threshold'] += rand_uniform(-s, s)
        mutations += 1

    if Util.randomFlipCoin(p):
        s = 0.1
        genome.conf['mutation_probability'] += rand_uniform(-s, s)
        mutations += 1

    return mutations
Ejemplo n.º 27
0
def expand(image, boxes, filler):
    original_h = image.size(1)
    original_w = image.size(2)

    max_scale = 1.5
    scale = rand_uniform(1, max_scale)

    new_h = int(scale * original_h)
    new_w = int(scale * original_w)

    filler = FloatTensor(filler)
    new_image = torch_ones(
        (3, new_h, new_w),
        dtype=torch_float) * filler.unsqueeze(1).unsqueeze(1)

    left = randint(0, new_w - original_w)
    right = left + original_w
    top = randint(0, new_h - original_h)
    bottom = top + original_h

    new_image[:, top:bottom, left:right] = image
    new_boxes = boxes + FloatTensor([left, top, left, top]).unsqueeze(0)

    return new_image, new_boxes
Ejemplo n.º 28
0
def PacmanGaussianMutator(genome, **args):
    if args["pmut"] <= 0.0: return 0
    listSize = len(genome)
    mutations = args["pmut"] * (listSize)

    mu = genome.getParam("gauss_mu")
    sigma = genome.getParam("gauss_sigma")

    if mu is None:
        mu = Consts.CDefG1DListMutRealMU
   
    if sigma is None:
        sigma = Consts.CDefG1DListMutRealSIGMA

    if mutations < 1.0:
        mutations = 0
        for it in xrange(listSize):
            if Util.randomFlipCoin(args["pmut"]):
                if it % 2 != 0:
                    final_value = genome[it] + rand_uniform(-0.3, 0.3)
                    final_value = max(final_value, genome.getParam("minSigma"))
                    final_value = min(final_value, genome.getParam("maxSigma"))
                
                    genome[it] = final_value
                elif it < listSize - 1:
                    final_value = genome[it] + rand_uniform(-30, 30)
                    final_value = max(final_value, genome.getParam("minMean"))
                    final_value = min(final_value, genome.getParam("maxMean"))
                
                    genome[it] = final_value
                else:
                    final_value = genome[it] + rand_uniform(-0.1, 0.1)
                    final_value = max(final_value, genome.getParam("minWallPenalty"))
                    final_value = min(final_value, genome.getParam("maxWallPenalty"))
                
                    genome[it] = final_value

                mutations += 1
   
    else: 
        for it in xrange(int(round(mutations))):
            which_gene = rand_randint(0, listSize - 1)
            if which_gene % 2 != 0:
                final_value = genome[which_gene ] + rand_uniform(-0.3, 0.3)
                final_value = max(final_value, genome.getParam("minSigma"))
                final_value = min(final_value, genome.getParam("maxSigma"))
            
                genome[which_gene] = final_value
            elif which_gene < listSize - 1:
                final_value = genome[which_gene] + rand_uniform(-30, 30)
                final_value = max(final_value, genome.getParam("minMean"))
                final_value = min(final_value, genome.getParam("maxMean"))
            
                genome[which_gene] = final_value
            else:
                final_value = genome[which_gene] + rand_uniform(-0.1, 0.1)
                final_value = max(final_value, genome.getParam("minWallPenalty"))
                final_value = min(final_value, genome.getParam("maxWallPenalty"))
            
                genome[which_gene] = final_value

    return int(mutations)
Ejemplo n.º 29
0
def random_distort_image(im, hue, saturation, exposure):
    dhue = rand_uniform(-hue, hue)
    dsat = rand_scale(saturation)
    dexp = rand_scale(exposure)
    res = distort_image(im, dhue, dsat, dexp)
    return res
Ejemplo n.º 30
0
def rand_scale(s):
    scale = rand_uniform(1, s)
    if (randint(1, 10000) % 2):
        return scale
    return 1. / scale
Ejemplo n.º 31
0
def rand(max):
    return int(rand_uniform(0, max))