Exemplo n.º 1
0
 /**
  * Gets the parameter.
  *
  * @param args the args
  * @return the parameter
  */
 public static Parameter getParameter(String[] args) {
   Parameter parameter = new Parameter();
   parameter
       .getParameterInputFeature()
       .setFeaturesDescription("audio2sphinx,1:1:0:0:0:0,13,0:0:0:0");
   parameter.readParameters(args);
   return parameter;
 }
Exemplo n.º 2
0
 /**
  * Load feature.
  *
  * @param parameter the parameter
  * @param clusterSet the cluster set
  * @param descriptor the descriptor
  * @return the audio feature set
  * @throws IOException Signals that an I/O exception has occurred.
  * @throws DiarizationException the diarization exception
  */
 public static AudioFeatureSet loadFeature(
     Parameter parameter, ClusterSet clusterSet, String descriptor)
     throws IOException, DiarizationException {
   String oldDescriptor = parameter.getParameterInputFeature().getFeaturesDescriptorAsString();
   parameter.getParameterInputFeature().setFeaturesDescription(descriptor);
   AudioFeatureSet result = MainTools.readFeatureSet(parameter, clusterSet);
   parameter.getParameterInputFeature().setFeaturesDescription(oldDescriptor);
   return result;
 }
Exemplo n.º 3
0
  /**
   * Gender.
   *
   * @param clusterSetBase the cluster set base
   * @param clusterSet the cluster set
   * @param featureSet the feature set
   * @param parameter the parameter
   * @return the cluster set
   * @throws Exception the exception
   */
  public ClusterSet gender(
      ClusterSet clusterSetBase,
      ClusterSet clusterSet,
      AudioFeatureSet featureSet,
      Parameter parameter)
      throws Exception {
    String mask = parameter.getParameterSegmentationOutputFile().getMask();
    boolean oldByCluster = parameter.getParameterScore().isByCluster();
    boolean oldGender = parameter.getParameterScore().isGender();

    String FeatureFormat = "featureSetTransformation";
    AudioFeatureSet featureSet2 =
        loadFeature(featureSet, parameter, clusterSet, FeatureFormat + ",1:3:2:0:0:0,13,1:1:0:0");
    String dir = "ester2";
    InputStream genderInputStream = getClass().getResourceAsStream(dir + "/gender.gmms");
    GMMArrayList genderVector =
        MainTools.readGMMContainer(genderInputStream, parameter.getParameterModel());
    parameter.getParameterScore().setByCluster(true);
    parameter.getParameterScore().setGender(true);
    ClusterSet clustersGender = MScore.make(featureSet2, clusterSet, genderVector, null, parameter);
    if (parameter.getParameterDiarization().isSaveAllStep()) {
      parameter.getParameterSegmentationOutputFile().setMask(mask + ".g.seg");
      MainTools.writeClusterSet(parameter, clustersGender, false);
    }
    parameter.getParameterSegmentationOutputFile().setMask(mask);
    parameter.getParameterScore().setByCluster(oldByCluster);
    parameter.getParameterScore().setGender(oldGender);

    return clustersGender;
  }
Exemplo n.º 4
0
  /**
   * Tun ester2 corpus.
   *
   * @param parameter the parameter
   * @throws DiarizationException the diarization exception
   * @throws Exception the exception
   */
  public void tunEster2Corpus(Parameter parameter) throws DiarizationException, Exception {
    // Parameter parameter = getParameter(arguments);

    corpusResult = new TreeMap<String, DiarizationResultList>();
    ClusterSet fullClusterSet = initialize(parameter);
    listOfClusterSet = MainTools.splitHypotesis(fullClusterSet);

    int nbThread = parameter.getParameterDiarization().getThread();

    diarizationList = new ArrayList<Diarization>(nbThread);

    for (int i = 0; i < nbThread; i++) {
      diarizationList.add(new Diarization());
      diarizationList.get(i).start();
    }

    while (isThreadAlive() == true) {
      Thread.sleep(10000);
    }

    logger.finer("**** ALL SHOWS ***");
    for (String key : corpusResult.keySet()) {
      DiarizationResultList values = corpusResult.get(key);
      values.log(key);
    }
  }
Exemplo n.º 5
0
  /**
   * Sanity check.
   *
   * @param clusterSet the cluster set
   * @param featureSet the feature set
   * @param parameter the parameter
   * @return the cluster set
   * @throws DiarizationException the diarization exception
   * @throws IOException Signals that an I/O exception has occurred.
   * @throws ParserConfigurationException the parser configuration exception
   * @throws SAXException the sAX exception
   * @throws TransformerException the transformer exception
   */
  public ClusterSet sanityCheck(
      ClusterSet clusterSet, AudioFeatureSet featureSet, Parameter parameter)
      throws DiarizationException, IOException, ParserConfigurationException, SAXException,
          TransformerException {
    String mask = parameter.getParameterSegmentationOutputFile().getMask();

    ClusterSet clustersSegInit = new ClusterSet();
    MSegInit.make(featureSet, clusterSet, clustersSegInit, parameter);
    clustersSegInit.collapse();
    if (parameter.getParameterDiarization().isSaveAllStep()) {
      parameter.getParameterSegmentationOutputFile().setMask(mask + ".i.seg");
      MainTools.writeClusterSet(parameter, clustersSegInit, false);
    }

    parameter.getParameterSegmentationOutputFile().setMask(mask);

    return clustersSegInit;
  }
Exemplo n.º 6
0
 /** Run. */
 public void run() {
   ClusterSet clusterSet = getNextClusterSet();
   while (clusterSet != null) {
     Parameter parameter = getParameter(arguments);
     parameter.show = clusterSet.getShowNames().first();
     logger.finer("-------------------------------------------");
     logger.finer("--- " + parameter.show + " ---");
     logger.finer("-------------------------------------------");
     TreeMap<String, DiarizationResultList> showResult;
     try {
       showResult = tunEster2Diarization(parameter, clusterSet);
       sumResult(showResult);
       System.gc();
     } catch (DiarizationException e) {
       logger.log(Level.SEVERE, "Diarization error", e);
       e.printStackTrace();
     } catch (Exception e) {
       logger.log(Level.SEVERE, "Exception error", e);
       e.printStackTrace();
     }
     clusterSet = getNextClusterSet();
   }
 }
Exemplo n.º 7
0
  public void run() throws Exception {
    try {
      SpkDiarizationLogger.setup();
      parameter = new Parameter();
      String[] parameterScoreIdent = {
        "",
        "--sGender",
        "--sByCluster",
        "--fInputDesc=audio2sphinx,1:3:2:0:0:0,13,1:1:300:4",
        "--sOutputFormat=seg,UTF8",
        fInputMask,
        "--sTop=8," + this.ubm_gmm,
        s_inputMaskRoot + baseName + ".spl.3.seg",
        s_outputMaskRoot + baseName + ".g.3.seg",
        "--tInputMask=" + gmm_model,
        "--sOutputMask=" + outputRoot + "/" + baseName + ".ident.M.GiacomoMameli.gmm.seg",
        show
      };
      parameter.readParameters(parameterScoreIdent);

      if (parameter.show.isEmpty() == false) {
        // clusters
        ClusterSet clusterSet = MainTools.readClusterSet(parameter);
        // FeatureSet featureSet2 = Diarization.loadFeature(parameter, clusterSetBase,
        // parameter.getParameterInputFeature().getFeaturesDescription().getFeaturesFormat()
        // + ",1:1:0:0:0:0,13,0:0:0:0");
        // ClusterSet clusterSet = new ClusterSet();
        // MSegInit.make(featureSet2, clusterSetBase, clusterSet, parameter);
        // clusterSet.collapse();
        // Features
        AudioFeatureSet featureSet = MainTools.readFeatureSet(parameter, clusterSet);
        // Top Gaussian model
        GMMArrayList gmmTopGaussianList = MainTools.readGMMForTopGaussian(parameter, featureSet);

        // Compute Model
        GMMArrayList gmmList = MainTools.readGMMContainer(parameter);

        clusterSetResult = make(featureSet, clusterSet, gmmList, gmmTopGaussianList, parameter);

        // System.out.println("===");
        // System.out.println(clusterSetResult.getFirstCluster().getInformations().replaceAll("]",
        // "").split("=")[1] );
        // Seg outPut
        MainTools.writeClusterSet(parameter, clusterSetResult, false);
      }
    } catch (DiarizationException e) {
      logger.log(Level.SEVERE, "error \t exception ", e);
      e.printStackTrace();
    }
  }
Exemplo n.º 8
0
 /**
  * Initialize.
  *
  * @param parameter the parameter
  * @return the cluster set
  * @throws DiarizationException the diarization exception
  * @throws Exception the exception
  */
 public ClusterSet initialize(Parameter parameter) throws DiarizationException, Exception {
   // ** get the first diarization
   logger.info("Initialize segmentation");
   ClusterSet clusterSet = null;
   if (parameter.getParameterDiarization().isLoadInputSegmentation()) {
     clusterSet = MainTools.readClusterSet(parameter);
     // seg IRIT
     // return clusterSet;
     // seg IRIT
   } else {
     clusterSet = new ClusterSet();
     Cluster cluster = clusterSet.createANewCluster("init");
     Segment segment =
         new Segment(
             parameter.show,
             0,
             1,
             cluster,
             parameter.getParameterSegmentationInputFile().getRate());
     cluster.addSegment(segment);
   }
   return clusterSet;
 }
Exemplo n.º 9
0
  /**
   * The main method.
   *
   * @param args the arguments
   */
  public static void main(String[] args) {
    try {
      SpkDiarizationLogger.setup();
      arguments = args;
      Parameter parameter = getParameter(args);
      if (args.length <= 1) {
        parameter.help = true;
      }
      parameter.logCmdLine(args);
      info(parameter, "Diarization");

      if (parameter.show.isEmpty() == false) {
        DiarizationTV diarizationTV = new DiarizationTV();
        if (parameter.getParameterDiarization().getSystem()
            == ParameterBNDiarization.SystemString[1]) {
          parameter
              .getParameterSegmentationSplit()
              .setSegmentMaximumLength(
                  (10 * parameter.getParameterSegmentationInputFile().getRate()));
        }
        if (parameter.getParameterDiarization().getThread() > 0) {
          logger.info("Diarization tuning");
          diarizationTV.tunEster2Corpus(parameter);
        } else {
          logger.info("Diarization BN");
          diarizationTV.ester2Version(parameter);
        }
      }
    } catch (DiarizationException e) {
      logger.log(Level.SEVERE, "Diarization error", e);
      e.printStackTrace();
    } catch (IOException e) {
      logger.log(Level.SEVERE, "IOExecption error", e);
      e.printStackTrace();
    } catch (Exception e) {
      logger.log(Level.SEVERE, "Execption error", e);
      e.printStackTrace();
    }
  }
Exemplo n.º 10
0
  /**
   * Ester2 version.
   *
   * @param parameter the parameter
   * @throws DiarizationException the diarization exception
   * @throws Exception the exception
   */
  public void ester2Version(Parameter parameter) throws DiarizationException, Exception {

    // ** Caution this system is developed using Sphinx MFCC computed with legacy mode
    ClusterSet referenceClusterSet = null;
    if (!parameter.getParameterSegmentationInputFile2().getMask().equals("")) {
      referenceClusterSet = MainTools.readTheSecondClusterSet(parameter);
    }
    ClusterSet uemClusterSet = null;
    if (!parameter.getParameterSegmentationInputFile3().getMask().equals("")) {
      referenceClusterSet = MainTools.readThe3rdClusterSet(parameter);
    }
    ParameterBNDiarization parameterDiarization = parameter.getParameterDiarization();
    // ** mask for the output of the segmentation file

    ClusterSet clusterSet = initialize(parameter);

    // ** load the features, sphinx format (13 MFCC with C0) or compute it form a wave file
    AudioFeatureSet featureSet =
        loadFeature(
            parameter,
            clusterSet,
            parameter.getParameterInputFeature().getFeaturesDescriptorAsString());
    featureSet.setCurrentShow(parameter.show);
    int nbFeatures = featureSet.getNumberOfFeatures();
    if (parameter.getParameterDiarization().isLoadInputSegmentation() == false) {
      clusterSet.getFirstCluster().firstSegment().setLength(nbFeatures);
    }
    // clusterSet.debug(3);
    ClusterSet clustersSegInit = sanityCheck(clusterSet, featureSet, parameter);
    ClusterSet clustersSeg = segmentation("GLR", "FULL", clustersSegInit, featureSet, parameter);
    // Seg IRIT
    // ClusterSet clustersSegInit = clusterSet;
    // ClusterSet clustersSeg = clusterSet;
    // Seg IRIT
    ClusterSet clustersLClust =
        clusteringLinear(
            parameterDiarization.getThreshold("l"), clustersSeg, featureSet, parameter);
    ClusterSet clustersHClust =
        clustering(parameterDiarization.getThreshold("h"), clustersLClust, featureSet, parameter);
    // MainTools.writeClusterSet(parameter, clustersHClust, false);

    ClusterSet clustersDClust =
        decode(8, parameterDiarization.getThreshold("d"), clustersHClust, featureSet, parameter);
    ClusterSet clustersSplitClust =
        speech("10,10,50", clusterSet, clustersSegInit, clustersDClust, featureSet, parameter);
    ClusterSet clustersGender = gender(clusterSet, clustersSplitClust, featureSet, parameter);

    if (parameter.getParameterDiarization().isCEClustering()) {
      ClusterSet clustersCLR =
          speakerClustering(
              parameterDiarization.getThreshold("c"),
              "ce",
              clustersSegInit,
              clustersGender,
              featureSet,
              parameter);
      MainTools.writeClusterSet(parameter, clustersCLR, false);
      if (referenceClusterSet != null) {
        DiarizationError computeError = new DiarizationError(referenceClusterSet, uemClusterSet);
        computeError.scoreOfMatchedSpeakers(clustersCLR);
      }
    } else {
      MainTools.writeClusterSet(parameter, clustersGender, false);
    }
  }
Exemplo n.º 11
0
  /**
   * Speaker clustering.
   *
   * @param threshold the threshold
   * @param method the method
   * @param clusterSetBase the cluster set base
   * @param clustersSet the clusters set
   * @param featureSet the feature set
   * @param parameter the parameter
   * @return the cluster set
   * @throws Exception the exception
   */
  public ClusterSet speakerClustering(
      double threshold,
      String method,
      ClusterSet clusterSetBase,
      ClusterSet clustersSet,
      AudioFeatureSet featureSet,
      Parameter parameter)
      throws Exception {
    String mask = parameter.getParameterSegmentationOutputFile().getMask();
    String oldMethod = parameter.getParameterClustering().getMethodAsString();
    double oldThreshold = parameter.getParameterClustering().getThreshold();
    String oldEMControl = parameter.getParameterEM().getEMControl();
    int oldNTop = parameter.getParameterTopGaussian().getScoreNTop();
    String oldSpeechDetectorMethod = parameter.getParameterInputFeature().getSpeechMethodAsString();
    double oldSpeechDetectorThreshold = parameter.getParameterInputFeature().getSpeechThreshold();

    // ** bottom up hierarchical classification using GMMs
    // ** one for each cluster, trained by MAP adaptation of a UBM composed of the fusion of
    // 4x128GMM
    // ** the feature normalization use feature mapping technique, after the cluster frames are
    // centered and reduced
    String dir = "ester2";
    InputStream ubmInputStream = getClass().getResourceAsStream(dir + "/ubm.gmm");
    GMMArrayList ubmVect =
        MainTools.readGMMContainer(ubmInputStream, parameter.getParameterModel());
    GMM ubm = ubmVect.get(0);
    // int nbCep = ubm.getDimension() + 1;
    String FeatureFormat = "featureSetTransformation";

    parameter.getParameterInputFeature().setSpeechMethod("E");
    parameter.getParameterInputFeature().setSpeechThreshold(0.1);

    AudioFeatureSet featureSet2 =
        loadFeature(
            featureSet, parameter, clustersSet, FeatureFormat + ",1:3:2:0:0:0,13,1:1:300:4");
    parameter.getParameterClustering().setMethod(method);
    parameter.getParameterClustering().setThreshold(threshold);
    parameter.getParameterEM().setEMControl("1,5,0.01");
    parameter.getParameterTopGaussian().setScoreNTop(5);
    // ---- Begin NEW v 1.13 ---

    // if (parameter.parameterSpeechDetector.useSpeechDetection() == true) {
    // MSpeechDetector.EnergyThresholdMethod(clustersSet, featureSet, parameter);
    // }
    // ---- End NEW v 1.13 ---

    boolean saveAll = parameter.getParameterDiarization().isSaveAllStep();
    parameter.getParameterDiarization().setSaveAllStep(false);
    ClusterSet clustersCLR = MClust.make(featureSet2, clustersSet, parameter, ubm);
    parameter.getParameterDiarization().setSaveAllStep(saveAll);

    parameter.getParameterSegmentationOutputFile().setMask(mask);
    if (parameter.getParameterDiarization().isSaveAllStep()) {
      parameter.getParameterSegmentationOutputFile().setMask(mask + ".c.seg");
      MainTools.writeClusterSet(parameter, clustersCLR, false);
    }
    parameter.getParameterSegmentationOutputFile().setMask(mask);
    parameter.getParameterClustering().setMethod(oldMethod);
    parameter.getParameterClustering().setThreshold(oldThreshold);
    parameter.getParameterEM().setEMControl(oldEMControl);
    parameter.getParameterTopGaussian().setScoreNTop(oldNTop);
    parameter.getParameterInputFeature().setSpeechMethod(oldSpeechDetectorMethod);
    parameter.getParameterInputFeature().setSpeechThreshold(oldSpeechDetectorThreshold);

    return clustersCLR;
  }
Exemplo n.º 12
0
  /**
   * Speech.
   *
   * @param threshold the threshold
   * @param clustersSetBase the clusters set base
   * @param clustersSegInit the clusters seg init
   * @param clustersDClust the clusters d clust
   * @param featureSet the feature set
   * @param parameter the parameter
   * @return the cluster set
   * @throws Exception the exception
   */
  public ClusterSet speech(
      String threshold,
      ClusterSet clustersSetBase,
      ClusterSet clustersSegInit,
      ClusterSet clustersDClust,
      AudioFeatureSet featureSet,
      Parameter parameter)
      throws Exception {
    String mask = parameter.getParameterSegmentationOutputFile().getMask();
    String oldDecoderPenalty = parameter.getParameterDecoder().getDecoderPenaltyAsString();

    // ** Reload MFCC, remove energy and add delta
    String FeatureFormat = "featureSetTransformation";
    AudioFeatureSet featureSet2 =
        loadFeature(
            featureSet, parameter, clustersSetBase, FeatureFormat + ",1:3:2:0:0:0,13,0:0:0:0");
    String dir = "ester2";
    // ** load the model : 8 GMMs with 64 diagonal components
    InputStream pmsInputStream = getClass().getResourceAsStream(dir + "/sms.gmms");
    GMMArrayList pmsVect =
        MainTools.readGMMContainer(pmsInputStream, parameter.getParameterModel());
    // ** set penalties for the i to j states
    // ** 10 for the first and second model corresponding to boad/narrowband silence
    // ** 50 for the other jingle speech (f0 f2 f3 fx), jingle and music

    parameter.getParameterDecoder().setDecoderPenalty(threshold);
    ClusterSet clustersPMSClust = MDecode.make(featureSet2, clustersSegInit, pmsVect, parameter);
    if (parameter.getParameterDiarization().isSaveAllStep()) {
      parameter.getParameterSegmentationOutputFile().setMask(mask + ".sms.seg");
      MainTools.writeClusterSet(parameter, clustersPMSClust, false);
    }

    parameter.getParameterSegmentationOutputFile().setMask(mask);
    parameter.getParameterDecoder().setDecoderPenalty(oldDecoderPenalty);

    // ** Filter the segmentation adj acoording the sms segmentation
    // ** add 25 frames to all speech segments
    // ** remove silence part if silence segment is less than 25 frames
    // ** if a speech segment is less than 150 frames, it will be merge to the left or right closest
    // segments

    int oldSegmentPadding = parameter.getParameterFilter().getSegmentPadding();
    int oldSilenceMinimumLength = parameter.getParameterFilter().getSilenceMinimumLength();
    int oldSpeechMinimumLength = parameter.getParameterFilter().getSpeechMinimumLength();
    String oldSegmentationFilterFile =
        parameter.getParameterSegmentationFilterFile().getClusterFilterName();
    parameter.getParameterFilter().setSegmentPadding(25);
    parameter.getParameterFilter().setSilenceMinimumLength(25);
    parameter.getParameterFilter().setSpeechMinimumLength(150);

    ClusterSet clustersFltClust = SFilter.make(clustersDClust, clustersPMSClust, parameter);
    if (parameter.getParameterDiarization().isSaveAllStep()) {
      parameter.getParameterSegmentationOutputFile().setMask(mask + ".flt.seg");
      MainTools.writeClusterSet(parameter, clustersFltClust, false);
      parameter.getParameterSegmentationOutputFile().setMask(mask);
    }

    // ** segments of more than 20s are split according of silence present in the pms or using a gmm
    // silence detector
    InputStream silenceInputStream = getClass().getResourceAsStream(dir + "/s.gmms");
    GMMArrayList sVect =
        MainTools.readGMMContainer(silenceInputStream, parameter.getParameterModel());
    parameter.getParameterSegmentationFilterFile().setClusterFilterName("iS,iT,j");
    ClusterSet clustersSplitClust =
        SSplitSeg.make(featureSet2, clustersFltClust, sVect, clustersPMSClust, parameter);
    if (parameter.getParameterDiarization().isSaveAllStep()) {
      parameter.getParameterSegmentationOutputFile().setMask(mask + ".spl.seg");
      MainTools.writeClusterSet(parameter, clustersSplitClust, false);
      parameter.getParameterSegmentationOutputFile().setMask(mask);
    }

    parameter.getParameterSegmentationFilterFile().setClusterFilterName(oldSegmentationFilterFile);
    parameter.getParameterFilter().setSegmentPadding(oldSegmentPadding);
    parameter.getParameterFilter().setSilenceMinimumLength(oldSilenceMinimumLength);
    parameter.getParameterFilter().setSpeechMinimumLength(oldSpeechMinimumLength);

    return clustersSplitClust;
  }
Exemplo n.º 13
0
  /**
   * Clustering linear.
   *
   * @param threshold the threshold
   * @param clusterSet the cluster set
   * @param featureSet the feature set
   * @param parameter the parameter
   * @return the cluster set
   * @throws Exception the exception
   */
  public ClusterSet clusteringLinear(
      double threshold, ClusterSet clusterSet, AudioFeatureSet featureSet, Parameter parameter)
      throws Exception {
    String mask = parameter.getParameterSegmentationOutputFile().getMask();
    String oldMethod = parameter.getParameterClustering().getMethodAsString();
    double oldThreshold = parameter.getParameterClustering().getThreshold();
    String oldModelKind = parameter.getParameterModel().getModelKindAsString();
    int oldNumberOfComponent = parameter.getParameterModel().getNumberOfComponents();

    parameter.getParameterModel().setModelKind("FULL");
    parameter.getParameterModel().setNumberOfComponents(1);
    parameter.getParameterClustering().setMethod("l");
    parameter.getParameterClustering().setThreshold(threshold);

    ClusterSet clustersLClust = MClust.make(featureSet, clusterSet, parameter, null);
    if (parameter.getParameterDiarization().isSaveAllStep()) {
      parameter.getParameterSegmentationOutputFile().setMask(mask + ".l.seg");
      MainTools.writeClusterSet(parameter, clustersLClust, false);
    }
    parameter.getParameterSegmentation().setMethod(oldMethod);
    parameter.getParameterModel().setNumberOfComponents(oldNumberOfComponent);
    parameter.getParameterModel().setModelKind(oldModelKind);
    parameter.getParameterClustering().setThreshold(oldThreshold);
    parameter.getParameterSegmentationOutputFile().setMask(mask);

    return clustersLClust;
  }
Exemplo n.º 14
0
  /**
   * Segmentation.
   *
   * @param method the method
   * @param kind the kind
   * @param clusterSet the cluster set
   * @param featureSet the feature set
   * @param parameter the parameter
   * @return the cluster set
   * @throws Exception the exception
   */
  public ClusterSet segmentation(
      String method,
      String kind,
      ClusterSet clusterSet,
      AudioFeatureSet featureSet,
      Parameter parameter)
      throws Exception {
    String mask = parameter.getParameterSegmentationOutputFile().getMask();

    String oldMethod = parameter.getParameterSegmentation().getMethodAsString();
    int oldNumberOfComponent = parameter.getParameterModel().getNumberOfComponents();
    String oldModelKind = parameter.getParameterModel().getModelKindAsString();

    parameter.getParameterSegmentation().setMethod(method);
    parameter.getParameterModel().setNumberOfComponents(1);
    parameter.getParameterModel().setModelKind(kind);
    ClusterSet clustersSeg = new ClusterSet();
    MSeg.make(featureSet, clusterSet, clustersSeg, parameter);
    if (parameter.getParameterDiarization().isSaveAllStep()) {
      parameter.getParameterSegmentationOutputFile().setMask(mask + ".s.seg");
      MainTools.writeClusterSet(parameter, clustersSeg, false);
    }

    parameter.getParameterSegmentation().setMethod(oldMethod);
    parameter.getParameterModel().setNumberOfComponents(oldNumberOfComponent);
    parameter.getParameterModel().setModelKind(oldModelKind);
    parameter.getParameterSegmentationOutputFile().setMask(mask);

    return clustersSeg;
  }
Exemplo n.º 15
0
  /**
   * Info.
   *
   * @param parameter the parameter
   * @param programName the program name
   * @throws IllegalArgumentException the illegal argument exception
   * @throws IllegalAccessException the illegal access exception
   * @throws InvocationTargetException the invocation target exception
   */
  public static void info(Parameter parameter, String programName)
      throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
    if (parameter.help) {
      logger.config(parameter.getSeparator2());
      logger.config("name = " + programName);
      logger.config(parameter.getSeparator());
      parameter.logShow();

      parameter.getParameterInputFeature().logAll(); // fInMask
      logger.config(parameter.getSeparator());
      parameter.getParameterSegmentationInputFile().logAll(); // sInMask
      parameter.getParameterSegmentationInputFile2().logAll(); // sInMask
      parameter.getParameterSegmentationOutputFile().logAll(); // sOutMask
      logger.config(parameter.getSeparator());
      parameter.getParameterDiarization().logAll();
      logger.config(parameter.getSeparator());
    }
  }
Exemplo n.º 16
0
  /**
   * Clustering.
   *
   * @param threshold the threshold
   * @param clusterSet the cluster set
   * @param featureSet the feature set
   * @param parameter the parameter
   * @return the cluster set
   * @throws Exception the exception
   */
  public ClusterSet clustering(
      double threshold, ClusterSet clusterSet, AudioFeatureSet featureSet, Parameter parameter)
      throws Exception {
    String mask = parameter.getParameterSegmentationOutputFile().getMask();
    String oldMethod = parameter.getParameterClustering().getMethodAsString();
    double oldThreshold = parameter.getParameterClustering().getThreshold();
    String oldModelKind = parameter.getParameterModel().getModelKindAsString();
    int oldNumberOfComponent = parameter.getParameterModel().getNumberOfComponents();

    // --- begin NEW v 1.14 / 4.16 / 4.18 / 4.20---
    parameter.getParameterClustering().setMethod("h");
    // parameter.getParameterClustering().setMethod("sr");
    // --- end NEW v 1.14 ---
    parameter.getParameterClustering().setThreshold(threshold);
    logger.finer(
        "method:"
            + parameter.getParameterClustering().getMethod()
            + " thr:"
            + parameter.getParameterClustering().getThreshold());
    parameter.getParameterModel().setModelKind("FULL");
    parameter.getParameterModel().setNumberOfComponents(1);
    ClusterSet clustersHClust = MClust.make(featureSet, clusterSet, parameter, null);
    if (parameter.getParameterDiarization().isSaveAllStep()) {
      parameter.getParameterSegmentationOutputFile().setMask(mask + ".h.seg");
      MainTools.writeClusterSet(parameter, clustersHClust, false);
    }

    parameter.getParameterSegmentation().setMethod(oldMethod);
    parameter.getParameterModel().setNumberOfComponents(oldNumberOfComponent);
    parameter.getParameterModel().setModelKind(oldModelKind);
    parameter.getParameterClustering().setThreshold(oldThreshold);
    parameter.getParameterSegmentationOutputFile().setMask(mask);

    return clustersHClust;
  }
Exemplo n.º 17
0
  /**
   * Tun ester2 diarization.
   *
   * @param parameter the parameter
   * @param clusterSet the cluster set
   * @return the tree map
   * @throws DiarizationException the diarization exception
   * @throws Exception the exception
   */
  public TreeMap<String, DiarizationResultList> tunEster2Diarization(
      Parameter parameter, ClusterSet clusterSet) throws DiarizationException, Exception {

    TreeMap<String, DiarizationResultList> result = new TreeMap<String, DiarizationResultList>();

    // double paramThr = parameter.getParameterClustering().getThreshold();
    lMin = parameter.getParameterDiarization().getThreshold("l");
    lMax = parameter.getParameterDiarization().getMaxThreshold("l");
    hMin = parameter.getParameterDiarization().getThreshold("h");
    hMax = parameter.getParameterDiarization().getMaxThreshold("h");
    dMin = parameter.getParameterDiarization().getThreshold("d");
    dMax = parameter.getParameterDiarization().getMaxThreshold("d");
    cMin = parameter.getParameterDiarization().getThreshold("c");
    cMax = parameter.getParameterDiarization().getMaxThreshold("c");

    String featureDesc = parameter.getParameterInputFeature().getFeaturesDescriptorAsString();

    AudioFeatureSet featureSet = null;
    ClusterSet clustersSegInit = null;

    if (parameter.getParameterDiarization().isLoadInputSegmentation() == false) {
      featureSet = loadFeature(parameter, clusterSet, featureDesc);
      featureSet.setCurrentShow(parameter.show);
      int nbFeatures = featureSet.getNumberOfFeatures();
      clusterSet.getFirstCluster().firstSegment().setLength(nbFeatures);
      clustersSegInit = sanityCheck(clusterSet, featureSet, parameter);
    } else {
      featureSet = loadFeature(parameter, clusterSet, featureDesc);
      featureSet.setCurrentShow(parameter.show);
      clustersSegInit = sanityCheck(clusterSet, featureSet, parameter);
      featureSet = loadFeature(parameter, clustersSegInit, featureDesc);
      featureSet.setCurrentShow(parameter.show);
    }

    // seg IRIT
    // ClusterSet clustersSegSave = clustersSegInit;
    // seg IRIT
    ClusterSet referenceClusterSet = MainTools.readTheSecondClusterSet(parameter);
    ClusterSet uemClusterSet = MainTools.readThe3rdClusterSet(parameter);

    if (parameter.getParameterDiarization().isLastStepOnly()) {
      String key = "l=" + lMin + " h=" + hMin + " d=" + dMin;
      DiarizationResultList values = null;
      if (parameter.getParameterDiarization().isCEClustering() == false) {
        logger.warning(" nothing to do isCEClustering == false");
      } else {
        values =
            tunEster2SpeakerCLRClustering(
                referenceClusterSet,
                uemClusterSet,
                key,
                "ce",
                clusterSet,
                clusterSet,
                featureSet,
                parameter);
      }
      result.put(key, values);
      return result;
    }

    ClusterSet clustersSegSave =
        segmentation("GLR", "FULL", clustersSegInit, featureSet, parameter);
    for (double l = lMin; l <= lMax; l += 0.5) {
      ClusterSet clustersSeg = clustersSegSave.clone();
      logger.finest("clustering l=" + l);
      ClusterSet clustersLClust = clusteringLinear(l, clustersSeg, featureSet, parameter);
      // ---- Begin NEW v 1.14 ---
      for (double h = hMin; h <= hMax; h += 0.5) {
        // for (double h = hMin; h <= hMax; h += 0.2) {
        // ---- end NEW v 1.14 ---
        // if (h > l) {
        ClusterSet clustersHClust = clustering(h, clustersLClust, featureSet, parameter);
        for (double d = dMin; d <= dMax; d += 50) {
          ClusterSet clustersDClust = decode(8, d, clustersHClust, featureSet, parameter);
          // double error = DiarizationError.scoreOfMatchedSpeakers(referenceClusterSet,
          // clustersDClust);
          ClusterSet clustersSplitClust =
              speech(
                  "10,10,50", clusterSet, clustersSegInit, clustersDClust, featureSet, parameter);
          ClusterSet clustersGender = gender(clusterSet, clustersSplitClust, featureSet, parameter);

          String key = "l=" + l + " h=" + h + " d=" + d;
          DiarizationResultList values = null;
          if (parameter.getParameterDiarization().isCEClustering() == false) {
            values = new DiarizationResultList(0, 0, 1);
            DiarizationError computeError =
                new DiarizationError(referenceClusterSet, uemClusterSet);
            DiarizationResult error = computeError.scoreOfMatchedSpeakers(clustersGender);
            values.setResult(0, 0, error);
            logger.finer(parameter.show + " key=" + key + " resultat du fichier");
            values.log("partial result: " + parameter.show + " " + key);
          } else {
            // V4.19 = CLUST_H_BIC_GMM_MAP
            // values = tunEster2SpeakerCLRClustering(referenceClusterSet, key, "bicgmmmap",
            // clustersGender, clustersGender, featureSet, parameter);
            // V5.16 = ce_d
            // values = tunEster2SpeakerCLRClustering(referenceClusterSet, key, "ce_d",
            // clustersGender, clustersGender, featureSet, parameter);
            values =
                tunEster2SpeakerCLRClustering(
                    referenceClusterSet,
                    uemClusterSet,
                    key,
                    "ce",
                    clustersGender,
                    clustersGender,
                    featureSet,
                    parameter);
          }
          if (result.containsKey(key)) {
            result.get(key).addResultArray(values);
          } else {
            result.put(key, values);
          }
        }
        // }
      }
    }
    return result;
  }
Exemplo n.º 18
0
  /**
   * Decode.
   *
   * @param nbComp the nb comp
   * @param threshold the threshold
   * @param clusterSet the cluster set
   * @param featureSet the feature set
   * @param parameter the parameter
   * @return the cluster set
   * @throws Exception the exception
   */
  public ClusterSet decode(
      int nbComp,
      double threshold,
      ClusterSet clusterSet,
      AudioFeatureSet featureSet,
      Parameter parameter)
      throws Exception {
    String mask = parameter.getParameterSegmentationOutputFile().getMask();
    String oldModelKind = parameter.getParameterModel().getModelKindAsString();
    int oldNumberOfComponent = parameter.getParameterModel().getNumberOfComponents();

    // ** Train GMM for each cluster.
    // ** GMM is a 8 component gaussian with diagonal covariance matrix
    // ** one GMM = one speaker = one cluster
    // ** initialization of the GMMs :
    // ** - same global covariance for each gaussian,
    // ** - 1/8 for the weight,
    // ** - means are initialized with the mean of 10 successive vectors taken
    parameter.getParameterModel().setModelKind("DIAG");
    parameter.getParameterModel().setNumberOfComponents(nbComp);
    GMMArrayList gmmInitVect = new GMMArrayList(clusterSet.clusterGetSize());
    MTrainInit.make(featureSet, clusterSet, gmmInitVect, parameter);
    // ** EM training of the initialized GMM
    GMMArrayList gmmVect = new GMMArrayList(clusterSet.clusterGetSize());
    MTrainEM.make(featureSet, clusterSet, gmmInitVect, gmmVect, parameter);

    // ** set the penalty to move from the state i to the state j, penalty to move from i to i is
    // equal to 0
    parameter.getParameterDecoder().setDecoderPenalty(String.valueOf(threshold));
    // ** make Viterbi decoding using the 8-GMM set
    // ** one state = one GMM = one speaker = one cluster
    ClusterSet clustersDClust = MDecode.make(featureSet, clusterSet, gmmVect, parameter);
    if (parameter.getParameterDiarization().isSaveAllStep()) {
      parameter.getParameterSegmentationOutputFile().setMask(mask + ".d.seg");
      MainTools.writeClusterSet(parameter, clustersDClust, false);
    }
    // ** move the boundaries of the segment in low energy part of the signal
    ClusterSet clustersAdjClust = SAdjSeg.make(featureSet, clustersDClust, parameter);
    if (parameter.getParameterDiarization().isSaveAllStep()) {
      parameter.getParameterSegmentationOutputFile().setMask(mask + ".adj.seg");
      MainTools.writeClusterSet(parameter, clustersAdjClust, false);
    }

    parameter.getParameterSegmentationOutputFile().setMask(mask);
    parameter.getParameterModel().setNumberOfComponents(oldNumberOfComponent);
    parameter.getParameterModel().setModelKind(oldModelKind);
    return clustersAdjClust;
  }
Exemplo n.º 19
0
  /**
   * Tun ester2 speaker clr clustering.
   *
   * @param referenceClusterSet the reference cluster set
   * @param uemClusterSet the uem cluster set
   * @param partialKey the partial key
   * @param method the method
   * @param clusterSetBase the cluster set base
   * @param clusterSet the cluster set
   * @param featureSet the feature set
   * @param parameter the parameter
   * @return the diarization result list
   * @throws Exception the exception
   */
  public DiarizationResultList tunEster2SpeakerCLRClustering(
      ClusterSet referenceClusterSet,
      ClusterSet uemClusterSet,
      String partialKey,
      String method,
      ClusterSet clusterSetBase,
      ClusterSet clusterSet,
      AudioFeatureSet featureSet,
      Parameter parameter)
      throws Exception {
    String oldSpeechDetectorMethod = parameter.getParameterInputFeature().getSpeechMethodAsString();
    double oldSpeechDetectorThreshold = parameter.getParameterInputFeature().getSpeechThreshold();
    String oldModelKind = parameter.getParameterModel().getModelKindAsString();
    int oldNumberOfComponent = parameter.getParameterModel().getNumberOfComponents();
    String oldMethod = parameter.getParameterClustering().getMethodAsString();
    double oldThreshold = parameter.getParameterClustering().getThreshold();

    String oldEMControl = parameter.getParameterEM().getEMControl();
    int oldNTop = parameter.getParameterTopGaussian().getScoreNTop();
    boolean oldSaveAll = parameter.getParameterDiarization().isSaveAllStep();

    DiarizationResultList localResult = new DiarizationResultList(cMin, cMax, mult);
    DiarizationError computeError = new DiarizationError(referenceClusterSet, uemClusterSet);
    double prevScore = cMin;

    // ---- Begin NEW v 1.13 ---
    parameter.getParameterInputFeature().setSpeechMethod("E");
    parameter.getParameterInputFeature().setSpeechThreshold(0.1);

    // ---- End NEW v 1.13 ---
    String FeatureFormat = "featureSetTransformation";
    String dir = "ester2";
    InputStream ubmInputStream = getClass().getResourceAsStream(dir + "/ubm.gmm");
    GMMArrayList ubmVect =
        MainTools.readGMMContainer(ubmInputStream, parameter.getParameterModel());
    GMM ubm = ubmVect.get(0);
    /*
     * int nbCep = 16; logger.info("---> nbCep:"+nbCep); FeatureSet featureSet2 = loadFeature(parameter, clusterSet, "audio16kHz2sphinx,1:3:2:0:0:0,"+nbCep+",1:1:300:4"); logger.info("---> nbCep:"+nbCep); //logger.fine("*** nbFeaturesNorm:" +
     * clusterSetBase.getLength());
     */
    // A tester

    AudioFeatureSet featureSet2 =
        loadFeature(featureSet, parameter, clusterSet, FeatureFormat + ",1:3:2:0:0:0,13,1:1:300:4");
    // v5.14
    // FeatureSet featureSet2 = loadFeature(featureSet, parameter, clusterSet, FeatureFormat
    // + ",1:3:2:0:0:0,13,1:1:0:0");
    parameter.getParameterModel().setModelKind("DIAG");
    parameter.getParameterModel().setNumberOfComponents(ubm.getNbOfComponents());
    parameter.getParameterClustering().setMethod(method);
    // ---- Begin NEW v 1.19 ---
    // parameter.getParameterEM().setEMControl("1,1,0.01");
    // parameter.getParameterClustering().setThreshold(0);
    // ---- End NEW v 1.19 ---
    parameter.getParameterClustering().setThreshold(cMax);
    parameter.getParameterEM().setEMControl("1,5,0.01");
    parameter.getParameterTopGaussian().setScoreNTop(5);
    parameter.getParameterDiarization().setSaveAllStep(false);

    CLRHClustering clustering = new CLRHClustering(clusterSet, featureSet2, parameter, ubm);
    // int nbCluster = clusterSet.clusterGetSize();
    // logger.info("initialise clustering CLR clusterSet:"+clusterSet);
    clustering.initialize();

    double score = clustering.getScoreOfCandidatesForMerging();
    DiarizationResult error = computeError.scoreOfMatchedSpeakers(clustering.getClusterSet());
    double errorRate = error.getErrorRate();
    localResult.setResult(prevScore, score, error);
    // prevScore = Math.max(score, prevScore);
    logger.fine(
        "first "
            + parameter.show
            + " key="
            + partialKey
            + " clrScore="
            + score
            + " clrErrorRate="
            + errorRate
            + " clrSize="
            + clustering.getSize()
            + "/"
            + referenceClusterSet.clusterGetSize());
    while ((score < cMax) && (clustering.getSize() > 1)) {
      localResult.setResult(prevScore, score, error);
      prevScore = Math.max(score, prevScore);
      clustering.mergeCandidates();

      // -- start V5.16 --
      // logger.info("--> Decoding");
      // ClusterSet decodeClusterSet = MDecode.make(featureSet2, clustering.getClusterSet(),
      // clustering.getGmmList(), parameter);
      // logger.info("--> Clustering");
      // featureSet2 = loadFeature(featureSet, parameter, decodeClusterSet, FeatureFormat
      // + ",1:3:2:0:0:0,13,1:1:300:4");
      // clustering = new CLRHClustering(decodeClusterSet, featureSet2, parameter, ubm);
      // clustering.initialize();
      // -- end V5.16 --

      score = clustering.getScoreOfCandidatesForMerging();
      error = computeError.scoreOfMatchedSpeakers(clustering.getClusterSet());
      errorRate = error.getErrorRate();
      // localResult.setResult(prevScore, score, error);
      // prevScore = Math.max(score, prevScore);
      logger.fine(
          parameter.show
              + " key="
              + partialKey
              + " clrScore="
              + score
              + " clrErrorRate="
              + errorRate
              + " clrSize="
              + clustering.getSize()
              + "/"
              + referenceClusterSet.clusterGetSize());
    }
    localResult.setResult(prevScore, score, error);
    localResult.setResult(score, cMax, error);
    logger.finer(parameter.show + " key=" + partialKey + " resultat du fichier");
    localResult.log("partial result: " + parameter.show + " " + partialKey);

    clustering.reset();

    parameter.getParameterModel().setNumberOfComponents(oldNumberOfComponent);
    parameter.getParameterModel().setModelKind(oldModelKind);
    parameter.getParameterClustering().setMethod(oldMethod);
    parameter.getParameterClustering().setThreshold(oldThreshold);
    parameter.getParameterEM().setEMControl(oldEMControl);
    parameter.getParameterTopGaussian().setScoreNTop(oldNTop);
    parameter.getParameterInputFeature().setSpeechMethod(oldSpeechDetectorMethod);
    parameter.getParameterInputFeature().setSpeechThreshold(oldSpeechDetectorThreshold);
    parameter.getParameterDiarization().setSaveAllStep(oldSaveAll);

    return localResult;
  }
Exemplo n.º 20
0
  public ClusterSet make(
      AudioFeatureSet featureSet,
      ClusterSet clusterSet,
      GMMArrayList gmmList,
      GMMArrayList gmmTopList,
      Parameter parameter)
      throws DiarizationException, IOException {
    logger.info("Compute Score");
    int size = gmmList.size();
    logger.finer("GMM size:" + size);
    ArrayList<String> genderString = new ArrayList<String>();
    ArrayList<String> bandwidthString = new ArrayList<String>();
    for (int i = 0; i < size; i++) {
      String gmmName = gmmList.get(i).getName();
      if (parameter.getParameterScore().isGender() == true) {
        if (gmmName.equals("MS")) {
          genderString.add(Cluster.genderStrings[1]);
          bandwidthString.add(Segment.bandwidthStrings[2]);
        } else if (gmmName.equals("FS")) {
          genderString.add(Cluster.genderStrings[2]);
          bandwidthString.add(Segment.bandwidthStrings[2]);
        } else if (gmmName.equals("MT")) {
          genderString.add(Cluster.genderStrings[1]);
          bandwidthString.add(Segment.bandwidthStrings[1]);
        } else if (gmmName.equals("FT")) {
          genderString.add(Cluster.genderStrings[2]);
          bandwidthString.add(Segment.bandwidthStrings[1]);
        } else {
          genderString.add(Cluster.genderStrings[0]);
          bandwidthString.add(Segment.bandwidthStrings[0]);
        }
      } else {
        genderString.add(Cluster.genderStrings[0]);
        bandwidthString.add(Segment.bandwidthStrings[0]);
      }
    }

    ClusterSet clusterSetResult = new ClusterSet();
    for (Cluster cluster : clusterSet.clusterSetValue()) {
      double[] sumScoreVector = new double[size];
      int[] sumLenghtVector = new int[size];
      double ubmScore = 0.0;
      GMM gmmTop = null;
      if (parameter.getParameterTopGaussian().getScoreNTop() >= 0) {
        gmmTop = gmmTopList.get(0);
      }
      Arrays.fill(sumScoreVector, 0.0);
      Arrays.fill(sumLenghtVector, 0);
      for (Segment currantSegment : cluster) {
        Segment segment = (currantSegment.clone());
        int end = segment.getStart() + segment.getLength();
        featureSet.setCurrentShow(segment.getShowName());
        double[] scoreVector = new double[size];
        double maxScore = 0.0;
        int idxMaxScore = 0;
        for (int i = 0; i < size; i++) {
          gmmList.get(i).score_initialize();
        }
        for (int start = segment.getStart(); start < end; start++) {
          for (int i = 0; i < size; i++) {
            GMM gmm = gmmList.get(i);
            if (parameter.getParameterTopGaussian().getScoreNTop() >= 0) {
              if (i == 0) {
                gmmTop.score_getAndAccumulateAndFindTopComponents(
                    featureSet, start, parameter.getParameterTopGaussian().getScoreNTop());
              }
              gmm.score_getAndAccumulateForComponentSubset(
                  featureSet, start, gmmTop.getTopGaussianVector());
            } else {
              gmm.score_getAndAccumulate(featureSet, start);
            }
          }
        }

        if (parameter.getParameterTopGaussian().getScoreNTop() >= 0) {
          ubmScore = gmmTop.score_getMeanLog();
          gmmTop.score_getSumLog();
          gmmTop.score_getCount();
          gmmTop.score_reset();
        }
        for (int i = 0; i < size; i++) {
          GMM gmm = gmmList.get(i);
          scoreVector[i] = gmm.score_getMeanLog();
          sumLenghtVector[i] += gmm.score_getCount();
          sumScoreVector[i] += gmm.score_getSumLog();
          if (i == 0) {
            maxScore = scoreVector[0];
            idxMaxScore = 0;
          } else {
            double value = scoreVector[i];
            if (maxScore < value) {
              maxScore = value;
              idxMaxScore = i;
            }
          }
          gmm.score_reset();
        }
        if (parameter.getParameterScore().isTNorm()) {
          double sumScore = 0;
          double sum2Score = 0;
          for (int i = 0; i < size; i++) {
            sumScore += scoreVector[i];
            sum2Score += (scoreVector[i] * scoreVector[i]);
          }
          for (int i = 0; i < size; i++) {
            double value = scoreVector[i];
            double mean = (sumScore - value) / (size - 1);
            double et = Math.sqrt(((sum2Score - (value * value)) / (size - 1)) - (mean * mean));
            scoreVector[i] = (value - mean) / et;
          }
        }
        if (parameter.getParameterScore().isGender() == true) {
          segment.setBandwidth(bandwidthString.get(idxMaxScore));
          segment.setInformation("segmentGender", genderString.get(idxMaxScore));
        }
        if (parameter.getParameterScore().isBySegment()) {
          for (int k = 0; k < size; k++) {
            double score = scoreVector[k];
            GMM gmm = gmmList.get(k);
            segment.setInformation("score:" + gmm.getName(), score);
            currantSegment.setInformation("score:" + gmm.getName(), score);
          }
          if (parameter.getParameterTopGaussian().getScoreNTop() >= 0) {
            segment.setInformation("score:" + "UBM", ubmScore);
            currantSegment.setInformation("score:" + "UBM", ubmScore);
          }
        }
        String newName = cluster.getName();
        if (parameter.getParameterScore().isByCluster() == false) {
          if ((scoreVector[idxMaxScore] > parameter.getParameterSegmentation().getThreshold())
              && (parameter.getParameterScore().getLabel()
                  != ParameterScore.LabelType.LABEL_TYPE_NONE.ordinal())) {
            if (parameter.getParameterScore().getLabel()
                == ParameterScore.LabelType.LABEL_TYPE_ADD.ordinal()) {
              newName += "_";
              newName += gmmList.get(idxMaxScore).getName();
            } else {
              newName = gmmList.get(idxMaxScore).getName();
            }
          }

          Cluster temporaryCluster = clusterSetResult.getOrCreateANewCluster(newName);
          temporaryCluster.setGender(cluster.getGender());
          if (parameter.getParameterScore().isGender() == true) {
            temporaryCluster.setGender(genderString.get(idxMaxScore));
          }
          temporaryCluster.addSegment(segment);
        }
      }
      if (parameter.getParameterScore().isByCluster()) {
        for (int i = 0; i < size; i++) {
          sumScoreVector[i] /= sumLenghtVector[i];
        }
        if (parameter.getParameterScore().isTNorm()) {
          double sumScore = 0;
          double sum2Score = 0;
          for (int i = 0; i < size; i++) {
            sumScore += sumScoreVector[i];
            sum2Score += (sumScoreVector[i] * sumScoreVector[i]);
          }
          for (int i = 0; i < size; i++) {
            double value = sumScoreVector[i];
            double mean = (sumScore - value) / (size - 1);
            double et = Math.sqrt(((sum2Score - (value * value)) / (size - 1)) - (mean * mean));
            sumScoreVector[i] = (value - mean) / et;
          }
        }
        double maxScore = sumScoreVector[0];
        int idxMaxScore = 0;
        for (int i = 1; i < size; i++) {
          double s = sumScoreVector[i];
          if (maxScore < s) {
            maxScore = s;
            idxMaxScore = i;
          }
        }
        String newName = cluster.getName();
        if ((sumScoreVector[idxMaxScore] > parameter.getParameterSegmentation().getThreshold())
            && (parameter.getParameterScore().getLabel()
                != ParameterScore.LabelType.LABEL_TYPE_NONE.ordinal())) {
          if (parameter.getParameterScore().getLabel()
              == ParameterScore.LabelType.LABEL_TYPE_ADD.ordinal()) {
            newName += "_";
            newName += gmmList.get(idxMaxScore).getName();
          } else {
            newName = gmmList.get(idxMaxScore).getName();
          }
          // logger.finer("cluster name=" + cluster.getName() + " new_name=" + newName);
        }
        Cluster tempororaryCluster = clusterSetResult.getOrCreateANewCluster(newName);
        tempororaryCluster.setGender(cluster.getGender());
        if (parameter.getParameterScore().isGender() == true) {
          tempororaryCluster.setGender(genderString.get(idxMaxScore));
        }
        tempororaryCluster.setName(newName);
        for (Segment currantSegment : cluster) {
          Segment segment = (currantSegment.clone());
          if (parameter.getParameterScore().isGender() == true) {
            segment.setBandwidth(bandwidthString.get(idxMaxScore));
          }
          tempororaryCluster.addSegment(segment);
        }
        for (int k = 0; k < size; k++) {
          double score = sumScoreVector[k];
          GMM gmm = gmmList.get(k);
          // logger.finer("****clustername = " + newName + " name=" + gmm.getName() + " =" + score+"
          // k="+k);
          // logger.log(Level.SEVERE, "****clustername = " + newName + " name=" + gmm.getName() + "
          // =" + score);
          tempororaryCluster.setInformation("score:" + gmm.getName(), score);
          ClusterResult cr = new ClusterResult();
          cr.setName(newName);
          cr.getValue().put(score, gmm.getName());
          System.out.println(
              "------ clusterResultSet.putValue(newName, gmm.getName(), score)=----------------");
          System.out.println(newName + "  " + gmm.getName() + "  " + score);
          if (isName(gmm.getName())) {
            clusterResultSet.putValue(newName, gmm.getName(), score);
          } else {
            System.out.println("*****************" + gmm.getName() + " Non nome valido  ");
          }
        }

        if (parameter.getParameterTopGaussian().getScoreNTop() >= 0) {
          // tempororaryCluster.putInformation("score:" + "length", ubmSumLen);
          // tempororaryCluster.putInformation("score:" + "UBM", ubmSumScore / ubmSumLen);
        }
      }
    }
    this.clusterSetResult = clusterSetResult;
    return clusterSetResult;
  }