bob.machine.LinearMachine

 
    # load PCA reference and check that it is still similar
    pca_ref = bob.machine.LinearMachine(bob.io.HDF5File(self.resource('pca_projector.hdf5')))
    self.assertTrue(pca_ref.is_similar_to(pca))
 

 
    # create a Linear Machine     # Runs whitening (first method)
    self.whitening_machine = bob.machine.LinearMachine(ivectors_matrix.shape[1],ivectors_matrix.shape[1])
 
    # create the whitening trainer

  def load_whitening_enroler(self, whitening_enroler_file):
    """Reads the whitening Enroler model from file"""
    # now, load the JFA base, if it is included in the file
 
    self.whitening_machine = bob.machine.LinearMachine(self.m_config.rt,self.m_config.rt)

    if self.m_config.subspace_dimension_pca is not None:
      proj_hdf5file.cd('/pca')
      self.m_pca_machine = bob.machine.LinearMachine(proj_hdf5file)
    proj_hdf5file.cd('/plda')
    self.m_plda_base = bob.machine.PLDABase(proj_hdf5file)

  def lda_load_projector(self, lda_projector_file):
    """Reads the UBM model from file"""
    # read LDA projector
    self.lda_machine = bob.machine.LinearMachine(bob.io.HDF5File(lda_projector_file))
    # Allocates an array for the projected data

  def wccn_load_projector(self, wccn_projector_file):
    """Reads the WCCN projector from file"""
    # read WCCN projector
    self.wccn_machine = bob.machine.LinearMachine(bob.io.HDF5File(wccn_projector_file))
    # Allocates an array for the projected data

 
    # create a Linear Machine     # Runs whitening (first method)
    self.whitening_machine = bob.machine.LinearMachine(ivectors_matrix.shape[1],ivectors_matrix.shape[1])
 
    # create the whitening trainer

  def load_whitening_enroler(self, whitening_enroler_file):
    """Reads the whitening Enroler model from file"""
    # now, load the JFA base, if it is included in the file
 
    self.whitening_machine = bob.machine.LinearMachine(self.m_config.rt,self.m_config.rt)

    if self.m_config.subspace_dimension_pca is not None:
      proj_hdf5file.cd('/pca')
      self.m_pca_machine = bob.machine.LinearMachine(proj_hdf5file)
    proj_hdf5file.cd('/plda')
    self.m_plda_base = bob.machine.PLDABase(proj_hdf5file)

  def lda_load_projector(self, lda_projector_file):
    """Reads the UBM model from file"""
    # read LDA projector
    self.lda_machine = bob.machine.LinearMachine(bob.io.HDF5File(lda_projector_file))
    # Allocates an array for the projected data

  def wccn_load_projector(self, wccn_projector_file):
    """Reads the WCCN projector from file"""
    # read WCCN projector
    self.wccn_machine = bob.machine.LinearMachine(bob.io.HDF5File(wccn_projector_file))
    # Allocates an array for the projected data

 
    # create a Linear Machine     # Runs whitening (first method)
    self.whitening_machine = bob.machine.LinearMachine(ivectors_matrix.shape[1],ivectors_matrix.shape[1])
 
    # create the whitening trainer

  def load_whitening_enroler(self, whitening_enroler_file):
    """Reads the whitening Enroler model from file"""
    # now, load the JFA base, if it is included in the file
 
    self.whitening_machine = bob.machine.LinearMachine(self.m_subspace_dimension_of_t, self.m_subspace_dimension_of_t)

  def lda_load_projector(self, lda_projector_file):
    """Reads the UBM model from file"""
    # read LDA projector
    self.lda_machine = bob.machine.LinearMachine(bob.io.HDF5File(lda_projector_file))
    # Allocates an array for the projected data

  def wccn_load_projector(self, wccn_projector_file):
    """Reads the WCCN projector from file"""
    # read WCCN projector
    self.wccn_machine = bob.machine.LinearMachine(bob.io.HDF5File(wccn_projector_file))
    # Allocates an array for the projected data

        print ".. Loading PCA machine: %s.." %pca_file_name
        pca_file = bob.io.HDF5File(pca_file_name)
        pca_machine = bob.machine.LinearMachine(pca_file)
        del pca_file
      else:

      if need_train:
        print ".. Applying PCA projection for training feature set.."
        train_F_pca = numpy.vstack([pca_machine(d) for d in train_F])
        train_M_pca = numpy.vstack([pca_machine(d) for d in train_M])
      print ".. Applying PCA projection for evaluation feature set.."
      eval_F_pca = numpy.vstack([pca_machine(d) for d in eval_F])
      eval_M_pca = numpy.vstack([pca_machine(d) for d in eval_M])

    if self.m_subspace_dimension_pca is not None:
      proj_hdf5file.cd('/pca')
      self.m_pca_machine = bob.machine.LinearMachine(proj_hdf5file)
    proj_hdf5file.cd('/plda')
    self.m_plda_base = bob.machine.PLDABase(proj_hdf5file)

    if self.m_subspace_dimension_pca is not None:
      proj_hdf5file.cd('/pca')
      self.m_pca_machine = bob.machine.LinearMachine(proj_hdf5file)
    proj_hdf5file.cd('/plda')
    self.m_plda_base = bob.machine.PLDABase(proj_hdf5file)

  except:
    try:
      machine = bob.machine.LinearMachine(macfile)
    except:
      print "Cannot load Linear or MLP machine from file %s" % args.machine

    valid_index = ~numpy.isnan(input.sum(axis=1))
    valid_data = input[valid_index,:]
    valid_output = machine(valid_data)
    output = numpy.ndarray((len(input), 1), dtype='float64')
    output[valid_index] = valid_output

      combined_matrix = numpy.dot(pca_machine.weights, self.m_machine.weights)
      # set new weight matrix (and new mean vector) of novel machine
      self.m_machine = bob.machine.LinearMachine(combined_matrix)
      self.m_machine.input_subtract = pca_machine.input_subtract
 

    self.m_variances = f.read("Eigenvalues")
    f.cd("/Machine")
    self.m_machine = bob.machine.LinearMachine(f)
    # Allocates an array for the projected data
    self.m_projected_feature = numpy.ndarray(self.m_machine.shape[1], numpy.float64)

    if(pcaFile != ''):
      hdf5File_pca    = bob.io.HDF5File(pcaFile,openmode_string='r')
      pcaMachine      = bob.machine.LinearMachine(hdf5File_pca)
      featureVector   = pca.pcareduce(pcaMachine, featureVector);
 

    if(machineType=='Linear'):
      hdf5File_linear = bob.io.HDF5File(machineFile,openmode_string='r')
      machine         = bob.machine.LinearMachine(hdf5File_linear)
      scores          = lda.get_scores(machine, featureVector)
    elif(machineType=='SVM'):