def __init__(self,
              n_dmps,
              n_bfs,
              used,
              default,
              conf,
              sm,
              im,
              dmp_type='discrete',
              ay=None):
     Agent.__init__(self, conf, sm, im)
     self.n_dmps, self.n_bfs = n_dmps, n_bfs
     self.current_m = zeros(self.conf.m_ndims)
     if ay is None:
         self.dmp = DmpPrimitive(n_dmps,
                                 n_bfs,
                                 used,
                                 default,
                                 type=dmp_type)
     else:
         self.dmp = DmpPrimitive(n_dmps,
                                 n_bfs,
                                 used,
                                 default,
                                 type=dmp_type,
                                 ay=ones(n_dmps) * 1.)
 def init_motor_DMP(self,
                    optim_initial_position=True,
                    optim_end_position=True,
                    default_motor_initial_position=None,
                    default_motor_end_position=None):
     default = np.zeros(self.n_dynamic_motor_dims * (self.n_bfs + 2))
     if not optim_initial_position:
         default[:self.
                 n_dynamic_motor_dims] = default_motor_initial_position or [
                     0.
                 ] * self.n_dynamic_motor_dims
         dims_optim = [False] * self.n_dynamic_motor_dims
     else:
         dims_optim = [True] * self.n_dynamic_motor_dims
     dims_optim += [True] * (self.n_dynamic_motor_dims * self.n_bfs)
     if not optim_end_position:
         default[-self.
                 n_dynamic_motor_dims:] = default_motor_end_position or [
                     0.
                 ] * self.n_dynamic_motor_dims
         dims_optim += [False] * self.n_dynamic_motor_dims
     else:
         dims_optim += [True] * self.n_dynamic_motor_dims
     self.motor_dmp = DmpPrimitive(self.n_dynamic_motor_dims,
                                   self.n_bfs,
                                   dims_optim,
                                   default,
                                   type='discrete',
                                   timesteps=self.move_steps)
Beispiel #3
0
    def __init__(self,
                 synth,
                 m_mins,
                 m_maxs,
                 s_mins,
                 s_maxs,
                 m_used,
                 s_used,
                 n_dmps,
                 n_bfs,
                 dmp_move_steps,
                 dmp_max_param,
                 sensory_traj_samples,
                 audio,
                 diva_path=None):

        self.m_mins = m_mins
        self.m_maxs = m_maxs
        self.s_mins = s_mins
        self.s_maxs = s_maxs
        self.m_used = m_used
        self.s_used = s_used
        self.n_dmps = n_dmps
        self.n_bfs = n_bfs
        self.dmp_move_steps = dmp_move_steps
        self.dmp_max_param = dmp_max_param
        self.samples = array(linspace(-1, self.dmp_move_steps - 1,
                                      sensory_traj_samples + 1),
                             dtype=int)[1:]
        self.audio = audio

        self.f0 = 1.
        self.pressure = 1.
        self.voicing = 1.

        if self.audio:
            import pyaudio
            self.pa = pyaudio.PyAudio()
            self.stream = self.pa.open(format=pyaudio.paFloat32,
                                       channels=1,
                                       rate=11025,
                                       output=True)
        if synth == "octave":
            self.synth = DivaOctaveSynth(diva_path)
        elif synth == "matlab":
            self.synth = DivaMatlabSynth()
        else:
            raise NotImplementedError

        self.art = array(
            [0.] * 10 + [self.f0, self.pressure, self.voicing]
        )  # 13 articulators is a constant from diva_synth.m in the diva source code
        self.max_params = array([1.] * self.n_dmps + [self.dmp_max_param] *
                                self.n_bfs * self.n_dmps + [1.] * self.n_dmps)

        self.dmp = DmpPrimitive(dmps=self.n_dmps,
                                bfs=self.n_bfs,
                                timesteps=self.dmp_move_steps)
        Environment.__init__(self, self.m_mins, self.m_maxs, self.s_mins,
                             self.s_maxs)
 def init_sensori_DMP(self,
                      optim_initial_position=True,
                      optim_end_position=True,
                      default_sensori_initial_position=None,
                      default_sensori_end_position=None):
     default = np.zeros(self.n_dynamic_sensori_dims *
                        (self.n_sensori_traj_points + 2))
     if not optim_initial_position:
         default[:self.
                 n_dynamic_sensori_dims] = default_sensori_initial_position
         dims_optim = [False] * self.n_dynamic_sensori_dims
     else:
         dims_optim = [True] * self.n_dynamic_sensori_dims
     dims_optim += [True] * (self.n_dynamic_sensori_dims *
                             self.n_sensori_traj_points)
     if not optim_end_position:
         default[-self.
                 n_dynamic_sensori_dims:] = default_sensori_end_position
         dims_optim += [False] * self.n_dynamic_sensori_dims
     else:
         dims_optim += [True] * self.n_dynamic_sensori_dims
     self.sensori_dmp = DmpPrimitive(self.n_dynamic_sensori_dims,
                                     self.n_sensori_traj_points,
                                     dims_optim,
                                     default,
                                     type='discrete',
                                     timesteps=self.move_steps)