示例#1
0
def new_sample_specified_attributes(sample, mask):
    """ mask[i] == True if we want to keep this attribute
    """
    f = lambda v: [x for x, b in izip(v, mask) if b]
    values, meta = f(sample.values), f(sample.meta)
    return Sample(values, meta, cls=sample.cls, cls_meta=sample.cls_meta,
        dist_fun=sample.dist_fun)
示例#2
0
    def sample(self, batch_size, indexes=None):
        # Get random indexes if not given
        if indexes is None:
            try:
                all_indexes = xrange(self.memory.size)
            except:
                all_indexes = range(self.memory.size)
            indexes = random.sample(all_indexes, batch_size)

        assert (self.memory.size > self.window_length)
        assert (batch_size == len(indexes))

        state_shape = np.shape(self.memory.buffer[0].state)

        samples = []
        for index in indexes:
            index = index % self.memory.size
            state_shape = np.shape(self.memory.buffer[0].state)

            # Sample index again if index is at the end of an episode
            # or index is at the ring buffer boundary
            while self.is_episode_end(index) or index == self.memory.index - 1:
                try:
                    all_indexes = xrange(self.memory.size)
                except:
                    all_indexes = range(self.memory.size)
                index = random.sample(all_indexes, 1)[0]

            states = np.zeros(state_shape + (self.window_length, ))
            next_states = np.zeros(state_shape + (self.window_length, ))

            # Get the most recent frames without crossing episode boundary
            for frame in range(self.window_length):
                frame_index = (index - frame) % self.memory.size
                if self.invalid_frame_index(frame_index, index, frame):
                    break
                state = self.memory.buffer[frame_index].state
                states[..., self.window_length - frame - 1] = state

            # Get the next frames
            next_state = self.memory.buffer[(index + 1) %
                                            self.memory.size].state
            next_states[..., :-1] = states[..., 1:]
            next_states[..., -1] = next_state

            action = self.memory.buffer[index].action
            reward = self.memory.buffer[index].reward
            is_terminal = self.memory.buffer[index].is_terminal

            sample = Sample(states, action, reward, next_states, is_terminal)
            samples.append(sample)

        return samples
示例#3
0
"""

import ROOT
from core import Sample, Var, Weights, PlotDetails, Cut, Selector

## Common weights
kQCD = Var('kQCD_fix')
kEW = Var('kEW_fix')

#-------------------------------------------------------------------------------
# tau-mu channel data
#-------------------------------------------------------------------------------
data = Sample(
    name='data',
    tlatex='data',
    fill_color=ROOT.kGreen + 2,
    line_color=ROOT.kBlack,
    marker_color=ROOT.kBlack,
    marker_style=20,
)

#-------------------------------------------------------------------------------
# signal samples
#-------------------------------------------------------------------------------
ZP_pd = PlotDetails(weights=Weights([kQCD]))
Zprime250tautau = Sample(
    name='Zprime250tautau',
    tlatex='Z\'_{SSM}(250)#rightarrow#tau#tau',
    fill_color=ROOT.kWhite,
    line_color=ROOT.kBlack,
    marker_color=ROOT.kBlack,
    marker_style=20,