diarize-jruby 0.2.0-java

data/README.md

@@ -0,0 +1,101 @@
+diarize-jruby
+=============
+
+This library provides an easy-to-use toolkit for speaker
+segmentation (diarization) and identification from audio.
+
+This library is being used within the BBC R&D World Service 
+archive prototype.
+
+See http://worldservice.prototyping.bbc.co.uk/programmes/X0403940 for
+an example.
+
+Speaker diarization
+-------------------
+
+This library gives acccess to the algorithm developed by the LIUM 
+for the ESTER 2 evaluation campaign and described in [Meigner2010].
+
+It wraps a binary JAR file compiled from 
+http://lium3.univ-lemans.fr/diarization/doku.php/welcome.
+
+
+Speaker identification
+----------------------
+
+This library also implements an algorithm for speaker identification
+based on the comparison of normalised speaker models, which can be 
+accessed through the Speaker#match method.
+
+This algorithm builds on top of the LIUM toolkit and uses the following 
+techniques:
+
+ * "M-Norm" normalisation of speaker models [Ben2003]
+ * The symmetric Kullback-Leibler divergence approximation described in [Do2003]
+ * The detection score specified in [Ben2005] 
+
+It also includes support for speaker supervectors [Campbell2006], which 
+can be used in combination with our ruby-lsh library for fast speaker 
+identification.
+
+Example use
+-----------
+
+This gem has been tested with jruby 1.7.2 onwards.
+
+    $ jruby -S gem install diarize-jruby
+    $ jruby -S irb
+    > require 'diarize'
+    > audio = Diarize::Audio.new URI('http://example.com/file.wav')
+    > audio.analyze!
+    > audio.segments
+    > audio.speakers
+    > audio.to_rdf
+    > speakers = audio.speakers
+    > speakers.first.gender
+    > speakers.first.model.mean\_log\_likelihood
+    > speakers.first.model.components.size
+    > audio.segments\_by\_speaker(speakers.first)[0].play
+    > audio.segments\_by\_speaker(speakers.first)[1].play
+    > ...
+    > speakers |= other\_speakers
+    > Diarize::Speaker.match(speakers)
+
+
+References
+----------
+
+[Meigner2010] S. Meignier and T. Merlin, "LIUM SpkDiarization: 
+An Open Source Toolkit For Diarization" in Proc. CMU SPUD Workshop, 
+March 2010, Dallas (Texas, USA)
+
+[Ben2003] M. Ben and F. Bimbot, "D-MAP: A Distance-Normalized Map 
+Estimation of SPeaker Models for Automatic Speaker Verification", 
+Proceedings of ICASSP, 2003
+
+[Do2003] M. N. Do, "Fast Approximation of Kullback-Leibler Distance 
+for Dependence Trees and Hidden Markov Models", 
+IEEE Signal Processing Letters, April 2003
+
+[Ben2005] M. Ben and G. Gravier and F. Bimbot. "A model space 
+framework for efficient speaker detection", 
+Proceedings of INTERSPEECH, 2005
+
+[Campbell2006] W. M. Campbell, D. E. Sturim and D. A. Reynolds, 
+"Support vector machines using GMM supervectors for speaker verification", 
+IEEE Signal Processing Letters, 2006, 13, 308-311
+
+Licensing terms and authorship
+------------------------------
+
+See 'COPYING' and 'AUTHORS' files.
+
+All code here, except where otherwise indicated, is licensed under
+the GNU Affero General Public License version 3. This license includes 
+many restrictions. If this causes a problem, please contact us. 
+See "AUTHORS" for contact details.
+
+This library includes a binary JAR file from the LIUM project, which code
+is licensed under the GNU General Public License version 2. See
+http://lium3.univ-lemans.fr/diarization/doku.php/licence for more
+information.

data/diarize-jruby.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name = "diarize-jruby"
+  s.version = "0.2.0"
+  s.date = "2013-06-14"
+  s.summary = "Speaker Diarization for JRuby"
+  s.email = "yves.raimond@bbc.co.uk"
+  s.homepage = "http://github.com/bbcrd/diarize"
+  s.description = "A library for JRuby wrapping the LIUM Speaker Diarization and including a few extra tools"
+  s.has_rdoc = false
+  s.authors = ['Yves Raimond']
+  s.files = ["README.md", "diarize-jruby.gemspec", "lib", "lib/diarize.rb", "lib/diarize/LIUM_SpkDiarization-4.2.jar", "lib/diarize/lium.rb", "lib/diarize/audio.rb", "lib/diarize/audio_player.rb", "lib/diarize/segmentation.rb", "lib/diarize/segment.rb", "lib/diarize/ubm.gmm", "lib/diarize/speaker.rb", "lib/diarize/super_vector.rb"]
+  s.platform = 'java'
+  s.add_dependency 'to-rdf'
+  s.add_dependency 'jblas-ruby'
+end
+

data/lib/diarize.rb

@@ -0,0 +1,22 @@
+# diarize-jruby
+# 
+# Copyright (c) 2013 British Broadcasting Corporation
+# 
+# Licensed under the GNU Affero General Public License version 3 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+# http://www.gnu.org/licenses/agpl
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require File.join(File.expand_path(File.dirname(__FILE__)), 'diarize', 'lium.rb')
+require File.join(File.expand_path(File.dirname(__FILE__)), 'diarize', 'audio.rb')
+require File.join(File.expand_path(File.dirname(__FILE__)), 'diarize', 'segment.rb')
+require File.join(File.expand_path(File.dirname(__FILE__)), 'diarize', 'segmentation.rb')
+require File.join(File.expand_path(File.dirname(__FILE__)), 'diarize', 'audio_player.rb')
+require File.join(File.expand_path(File.dirname(__FILE__)), 'diarize', 'super_vector.rb')

data/lib/diarize/audio.rb

@@ -0,0 +1,194 @@
+# diarize-jruby
+# 
+# Copyright (c) 2013 British Broadcasting Corporation
+# 
+# Licensed under the GNU Affero General Public License version 3 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+# http://www.gnu.org/licenses/agpl
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require File.join(File.expand_path(File.dirname(__FILE__)), 'lium')
+require File.join(File.expand_path(File.dirname(__FILE__)), 'segmentation')
+require File.join(File.expand_path(File.dirname(__FILE__)), 'speaker')
+
+require 'rubygems'
+require 'to_rdf'
+require 'uri'
+
+module Diarize
+
+  class Audio
+
+    attr_reader :path, :file
+
+    def initialize(uri)
+      @uri = uri
+      if uri.scheme == 'file'
+        # Local file
+        @path = uri.path
+      else
+        # Remote file, we get it locally
+        @path = '/tmp/' + URI.escape(uri.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+        Kernel.system("wget #{uri} -O #{@path}")
+      end
+      @file = File.new @path
+    end
+
+    def analyze!(train_speaker_models = true)
+      parameter = fr.lium.spkDiarization.parameter.Parameter.new
+      parameter.show = show
+      # 12 MFCC + Energy
+      # 1: static coefficients are present in the file
+      # 1: energy coefficient is present in the file
+      # 0: delta coefficients are not present in the file
+      # 0: delta energy coefficient is not present in the file
+      # 0: delta delta coefficients are not present in the file
+      # 0: delta delta energy coefficient is not present in the file
+      # 13: total size of a feature vector in the mfcc file
+      # 0:0:0: no feature normalization
+      parameter.parameterInputFeature.setFeaturesDescription('audio2sphinx,1:1:0:0:0:0,13,0:0:0:0')
+      parameter.parameterDiarization.cEClustering = true # We use CE clustering by default
+      parameter.parameterInputFeature.setFeatureMask(@path)
+      @clusters = ester2(parameter)
+      @segments = Segmentation.from_clusters(self, @clusters)
+      train_speaker_gmms if train_speaker_models
+    end
+
+    def clean!
+      return if @uri.scheme == 'file' # Don't delete local file if initialised from local URI
+      File.delete(@path)
+    end
+
+    def segments
+      raise Exception.new('You need to run analyze! before being able to access the analysis results') unless @segments
+      @segments
+    end
+
+    def speakers
+      return @speakers if @speakers
+      @speakers = segments.map { |segment| segment.speaker }.uniq
+    end
+
+    def segments_by_speaker(speaker)
+      segments.select { |segment| segment.speaker == speaker }
+    end
+
+    def duration_by_speaker(speaker)
+      return unless speaker
+      segments = segments_by_speaker(speaker)
+      duration = 0.0
+      segments.each { |segment| duration += segment.duration }
+      duration
+    end
+
+    def top_speakers
+      speakers.sort {|s1, s2| duration_by_speaker(s1) <=> duration_by_speaker(s2)}.reverse
+    end
+
+    include ToRdf
+
+    def namespaces
+      super.merge 'ws' => 'http://wsarchive.prototype0.net/ontology/', 'mo' => 'http://purl.org/ontology/mo/'
+    end
+
+    def uri
+      @uri
+    end
+
+    def uri=(uri)
+      @uri = uri
+    end
+
+    def base_uri
+      # Remove the fragment if there is one
+      base = uri.clone
+      base.fragment = nil
+      base
+    end
+
+    def type_uri
+      @type_uri || 'mo:AudioFile'
+    end
+
+    def type_uri=(type_uri)
+      @type_uri = type_uri
+    end
+
+    def rdf_mapping
+      { 'ws:segment' => segments }
+    end
+
+    def show
+      # The LIUM show name will be the file name, without extension or directory
+      File.expand_path(@path).split('/')[-1].split('.')[0]
+    end
+
+    protected
+
+    def train_speaker_gmms
+      segments # Making sure we have pre-computed segments and clusters
+      # Would be nice to reuse GMMs computed as part of the segmentation process
+      # but not sure how to access them without changing the Java API
+
+      # Start by copying models from the universal background model, one per speaker, using MTrainInit
+      parameter = fr.lium.spkDiarization.parameter.Parameter.new
+      parameter.parameterInputFeature.setFeaturesDescription('audio2sphinx,1:3:2:0:0:0,13,1:1:300:4')
+      parameter.parameterInputFeature.setFeatureMask(@path)
+      parameter.parameterInitializationEM.setModelInitMethod('copy')
+      parameter.parameterModelSetInputFile.setMask(File.join(File.expand_path(File.dirname(__FILE__)), 'ubm.gmm'))
+      features = fr.lium.spkDiarization.lib.MainTools.readFeatureSet(parameter, @clusters)
+      init_vect = java.util.ArrayList.new(@clusters.cluster_get_size)
+      fr.lium.spkDiarization.programs.MTrainInit.make(features, @clusters, init_vect, parameter)
+
+      # Adapt models to individual speakers detected in the audio, using MTrainMap
+      parameter = fr.lium.spkDiarization.parameter.Parameter.new
+      parameter.parameterInputFeature.setFeaturesDescription('audio2sphinx,1:3:2:0:0:0,13,1:1:300:4')
+      parameter.parameterInputFeature.setFeatureMask(@path)
+      parameter.parameterEM.setEMControl('1,5,0.01')
+      parameter.parameterVarianceControl.setVarianceControl('0.01,10.0')
+      parameter.show = show
+      features.setCurrentShow(parameter.show)
+      gmm_vect = java.util.ArrayList.new
+      fr.lium.spkDiarization.programs.MTrainMAP.make(features, @clusters, init_vect, gmm_vect, parameter)
+
+      # Populating the speakers with their GMMs
+      gmm_vect.each_with_index do |speaker_model, i|
+        speakers[i].model = speaker_model
+      end
+    end
+
+    def ester2(parameter)
+      diarization = fr.lium.spkDiarization.system.Diarization.new
+      parameterDiarization = parameter.parameterDiarization
+      clusterSet = diarization.initialize__method(parameter)
+      featureSet = fr.lium.spkDiarization.system.Diarization.load_feature(parameter, clusterSet, parameter.parameterInputFeature.getFeaturesDescString())
+      featureSet.setCurrentShow(parameter.show)
+      nbFeatures = featureSet.getNumberOfFeatures
+      clusterSet.getFirstCluster().firstSegment().setLength(nbFeatures) unless parameter.parameterDiarization.isLoadInputSegmentation
+      clustersSegInit = diarization.sanityCheck(clusterSet, featureSet, parameter)
+      clustersSeg = diarization.segmentation("GLR", "FULL", clustersSegInit, featureSet, parameter)
+      clustersLClust = diarization.clusteringLinear(parameterDiarization.getThreshold("l"), clustersSeg, featureSet, parameter)
+      clustersHClust = diarization.clustering(parameterDiarization.getThreshold("h"), clustersLClust, featureSet, parameter)
+      clustersDClust = diarization.decode(8, parameterDiarization.getThreshold("d"), clustersHClust, featureSet, parameter)
+      clustersSplitClust = diarization.speech("10,10,50", clusterSet, clustersSegInit, clustersDClust, featureSet, parameter)
+      clusters = diarization.gender(clusterSet, clustersSplitClust, featureSet, parameter)
+      if parameter.parameterDiarization.isCEClustering
+        # If true, the program computes the NCLR/CE clustering at the end. 
+        # The diarization error rate is minimized. 
+        # If this option is not set, the program stops right after the detection of the gender 
+        # and the resulting segmentation is sufficient for a transcription system.
+        clusters = diarization.speakerClustering(parameterDiarization.getThreshold("c"), "ce", clusterSet, clusters, featureSet, parameter)
+      end
+      clusters
+    end
+
+  end
+
+end

data/lib/diarize/audio_player.rb

@@ -0,0 +1,42 @@
+# diarize-jruby
+# 
+# Copyright (c) 2013 British Broadcasting Corporation
+# 
+# Licensed under the GNU Affero General Public License version 3 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+# http://www.gnu.org/licenses/agpl
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'java'
+
+module Diarize
+
+  class AudioPlayer
+
+    def play(file, start=0.0, duration=10.0)
+      java_file = java.io.File.new(file.path)
+      stream = javax.sound.sampled.AudioSystem.getAudioInputStream(java_file)
+      clip = javax.sound.sampled.AudioSystem.clip
+      clip.open(stream)
+      clip.setMicrosecondPosition(start * 1000000)
+      clip.start
+      begin
+        sleep(duration)
+      rescue Exception
+        $stderr.puts 'Stopping playback'
+      end
+      clip.stop
+      clip.close
+      stream.close
+    end
+
+  end
+
+end

data/lib/diarize/lium.rb

@@ -0,0 +1,22 @@
+# diarize-jruby
+# 
+# Copyright (c) 2013 British Broadcasting Corporation
+# 
+# Licensed under the GNU Affero General Public License version 3 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+# http://www.gnu.org/licenses/agpl
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'java'
+require File.join(File.expand_path(File.dirname(__FILE__)), 'LIUM_SpkDiarization-4.2.jar')
+
+def fr
+  Java::Fr
+end

data/lib/diarize/segment.rb

@@ -0,0 +1,74 @@
+# diarize-jruby
+# 
+# Copyright (c) 2013 British Broadcasting Corporation
+# 
+# Licensed under the GNU Affero General Public License version 3 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+# http://www.gnu.org/licenses/agpl
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require File.join(File.expand_path(File.dirname(__FILE__)), 'audio_player')
+
+require 'rubygems'
+require 'to_rdf'
+require 'uri'
+
+module Diarize
+
+  class Segment
+
+    attr_reader :start, :duration, :gender, :bandwidth
+
+    def initialize(audio, start, duration, gender, bandwidth, speaker_id)
+      @audio = audio
+      @start = start
+      @duration = duration
+      @bandwidth = bandwidth
+      @speaker_id = speaker_id
+      @speaker_gender = gender
+    end
+
+    def speaker
+      Speaker.find_or_create(URI("#{@audio.base_uri}##{@speaker_id}"), @speaker_gender)
+    end
+
+    def play
+      player = AudioPlayer.new
+      player.play(@audio.file, start, duration)
+    end
+
+    include ToRdf
+
+    def namespaces
+      super.merge 'ws' => 'http://wsarchive.prototype0.net/ontology/'
+    end
+
+    def uri
+      # http://www.w3.org/TR/media-frags/
+      URI("#{@audio.base_uri}#t=#{start},#{start+duration}")
+    end
+
+    def type_uri
+      'ws:Segment'
+    end
+
+    def rdf_mapping
+      {
+        'ws:start' => start,
+        'ws:duration' => duration,
+        'ws:gender' => gender,
+        'ws:bandwidth' => bandwidth,
+        'ws:speaker' => speaker,
+      }
+    end
+
+  end
+
+end

data/lib/diarize/segmentation.rb

@@ -0,0 +1,55 @@
+# diarize-jruby
+# 
+# Copyright (c) 2013 British Broadcasting Corporation
+# 
+# Licensed under the GNU Affero General Public License version 3 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+# http://www.gnu.org/licenses/agpl
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require File.join(File.expand_path(File.dirname(__FILE__)), 'segment')
+
+module Diarize
+
+  class Segmentation
+
+    def self.from_seg_file(audio, seg_file)
+      segmentation = []
+      File.open(seg_file).lines.each do |line|
+        next if line.start_with? ';;'
+        parts = line.split(' ')
+        start = parts[2].to_i / 100.0
+        duration = parts[3].to_i / 100.0
+        gender = parts[4]
+        bandwidth = parts[6]
+        speaker_id = parts[7]
+        segmentation << Segment.new(audio, start, duration, gender, bandwidth, speaker_id)
+      end
+      segmentation
+    end
+
+    def self.from_clusters(audio, clusters)
+      segmentation = []
+      clusters.each do |speaker_id|
+        cluster = clusters.get_cluster(speaker_id)
+        gender = cluster.gender
+        bandwidth = cluster.bandwidth
+        cluster.each do |segment|
+          start = segment.start_in_second
+          duration = segment.length_in_second
+          segmentation << Segment.new(audio, start, duration, gender, bandwidth, speaker_id)
+        end
+      end
+      segmentation
+    end
+
+  end
+
+end

data/lib/diarize/speaker.rb

@@ -0,0 +1,187 @@
+# diarize-jruby
+# 
+# Copyright (c) 2013 British Broadcasting Corporation
+# 
+# Licensed under the GNU Affero General Public License version 3 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+# http://www.gnu.org/licenses/agpl
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'rubygems'
+require 'to_rdf'
+require 'jblas'
+
+module Diarize
+
+  class Speaker
+
+    include JBLAS
+
+    # Some possible matching heuristics if using GDMAP:
+    # - speaker mean_log_likelihood needs to be more than -33 to be considered for match
+    # - distance between two speakers need to be less than distance between speaker and universal model + detection threshold to be considered
+
+    @@log_likelihood_threshold = -33
+    @@detection_threshold = 0.2 # Need to learn that parameter
+
+    @@speakers = {}
+
+    attr_accessor :model_uri, :model, :normalized
+    attr_reader :gender
+
+    def initialize(uri = nil, gender = nil, model_file = nil)
+      @model = Speaker.load_model(model_file) if model_file
+      @uri = uri
+      @gender = gender
+      @normalized = false
+    end
+
+    def self.ubm
+      speaker = Speaker.new
+      speaker.normalized = true
+      speaker.model = Speaker.load_model(File.join(File.expand_path(File.dirname(__FILE__)), 'ubm.gmm'))
+      speaker
+    end
+
+    def mean_log_likelihood
+      @mean_log_likelihood ? @mean_log_likelihood : model.mean_log_likelihood # Will be NaN if model was loaded from somewhere
+    end
+
+    def mean_log_likelihood=(mll)
+      @mean_log_likelihood = mll
+    end
+
+    def save_model(filename)
+      # TODO perhaps a warning if a normalised model is being saved?
+      write_gmm(filename, @model)
+    end
+
+    def self.detection_threshold=(threshold)
+      @@detection_threshold = threshold
+    end
+
+    def self.detection_threshold
+      @@detection_threshold
+    end
+
+    def self.load_model(filename)
+      read_gmm(filename)
+    end
+
+    def self.find_or_create(uri, gender)
+      return @@speakers[uri] if @@speakers[uri]
+      @@speakers[uri] = Speaker.new(uri, gender)
+    end
+
+    def self.divergence(speaker1, speaker2)
+      # TODO bundle in mean_log_likelihood to weight down unlikely models? 
+      return unless speaker1.model and speaker2.model
+      # MAP Gaussian divergence
+      # See "A model space framework for efficient speaker detection", Interspeech'05
+      divergence_lium(speaker1, speaker2)
+    end
+
+    def self.divergence_lium(speaker1, speaker2)
+      fr.lium.spkDiarization.libModel.Distance.GDMAP(speaker1.model, speaker2.model)
+    end
+
+    def self.divergence_ruby(speaker1, speaker2)
+      SuperVector.divergence(speaker1.supervector, speaker2.supervector)
+    end
+
+    def self.match_sets(speakers1, speakers2)
+      matches = []
+      speakers1.each do |s1|
+        speakers2.each do |s2|
+          matches << [ s1, s2 ] if s1.same_speaker_as(s2)
+        end
+      end
+      matches
+    end
+
+    def self.match(speakers)
+      speakers.combination(2).select { |s1, s2| s1.same_speaker_as(s2) }
+    end
+
+    def normalize!
+      unless @normalized
+        # Applies M-Norm from "D-MAP: a Distance-Normalized MAP Estimation of Speaker Models for Automatic Speaker Verification"
+        # to the associated GMM, placing it on a unit hyper-sphere with a UBM centre (model will be at distance one from the UBM
+        # according to GDMAP)
+        # Using supervectors: vector = (1.0 / distance_to_ubm) * vector + (1.0 - 1.0 / distance_to_ubm) * ubm_vector
+        speaker_ubm = Speaker.ubm
+        distance_to_ubm = Math.sqrt(Speaker.divergence(self, speaker_ubm))
+        model.nb_of_components.times do |k|
+          gaussian = model.components.get(k)
+          gaussian.dim.times do |i|
+            normalized_mean = (1.0 / distance_to_ubm) * gaussian.mean(i) + (1.0 - 1.0 / distance_to_ubm)  * speaker_ubm.model.components.get(k).mean(i)
+            gaussian.set_mean(i, normalized_mean) 
+          end
+        end
+        @normalized = true
+      end
+      @normalized
+    end
+
+    def same_speaker_as(other)
+      # Detection score defined in Ben2005
+      return unless [ self.mean_log_likelihood, other.mean_log_likelihood ].min > @@log_likelihood_threshold
+      self.normalize!
+      other.normalize!
+      detection_score = 1.0 - Speaker.divergence(other, self)
+      detection_score > @@detection_threshold
+    end
+
+    def supervector
+      # TODO: cache only when normalized
+      @supervector ||= SuperVector.generate_from_model(model)
+    end
+
+    include ToRdf
+
+    def namespaces
+      super.merge 'ws' => 'http://wsarchive.prototype0.net/ontology/'
+    end
+
+    def uri
+      @uri
+    end
+
+    def type_uri
+      'ws:Speaker'
+    end
+
+    def rdf_mapping
+      { 'ws:gender' => gender, 'ws:model' => model_uri, 'ws:mean_log_likelihood' => model.mean_log_likelihood, 'ws:supervector_hash' => supervector.hash.to_s }
+    end 
+
+    protected
+
+    def self.read_gmm(filename)
+      gmmlist = java.util.ArrayList.new
+      input = fr.lium.spkDiarization.lib.IOFile.new(filename, 'rb')
+      input.open
+      fr.lium.spkDiarization.libModel.ModelIO.readerGMMContainer(input, gmmlist)
+      input.close
+      gmmlist.to_a.first
+    end
+
+    def write_gmm(filename, model)
+      gmmlist = java.util.ArrayList.new
+      gmmlist << model
+      output = fr.lium.spkDiarization.lib.IOFile.new(filename, 'wb')
+      output.open
+      fr.lium.spkDiarization.libModel.ModelIO.writerGMMContainer(output, gmmlist)
+      output.close
+    end
+
+  end
+
+end

data/lib/diarize/super_vector.rb

@@ -0,0 +1,86 @@
+# diarize-jruby
+# 
+# Copyright (c) 2013 British Broadcasting Corporation
+# 
+# Licensed under the GNU Affero General Public License version 3 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+# http://www.gnu.org/licenses/agpl
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Diarize
+
+  class SuperVector
+
+    include JBLAS
+
+    attr_reader :vector
+
+    def initialize(vector)
+      @vector = vector
+    end
+
+    def self.generate_from_model(model)
+      # Generates a supervector from a LIUM GMM
+      dim = model.nb_of_components * model.components.get(0).dim
+      vector = DoubleMatrix.new(1, dim)
+      model.nb_of_components.times do |k|
+        gaussian = model.components.get(k)
+        gaussian.dim.times do |i|
+          vector[k * gaussian.dim + i] = gaussian.mean(i)
+        end
+      end
+      SuperVector.new(vector)
+    end
+
+    def self.ubm_gaussian_weights
+      # Returns a vector of gaussian weights, same dimension as speaker's super vectors
+      @@ubm_gaussian_weights ||= (
+        ubm = Speaker.ubm
+        weights = DoubleMatrix.new(1, ubm.supervector.dim)
+        ubm.model.nb_of_components.times do |k|
+          gaussian = ubm.model.components.get(k)
+          gaussian.dim.times do |i|
+            weights[k * gaussian.dim + i] = gaussian.weight
+          end
+        end
+        weights
+      )
+    end
+
+    def self.ubm_covariance
+      # Returns a vector of diagonal covariances, same dimension as speaker's super vectors
+      @@ubm_covariance ||= (
+        ubm = Speaker.ubm
+        cov = DoubleMatrix.new(1, ubm.supervector.dim)
+        ubm.model.nb_of_components.times do |k|
+          gaussian = ubm.model.components.get(k)
+          gaussian.dim.times do |i|
+            cov[k * gaussian.dim + i] = gaussian.getCovariance(i, i)
+          end
+        end
+        cov
+      )
+    end
+
+    def self.divergence(sv1, sv2)
+      ubm_gaussian_weights.mul(((sv1.vector - sv2.vector) ** 2) / ubm_covariance).sum
+    end
+
+    def dim
+      @vector.columns
+    end
+
+    def hash
+      @vector.hash
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: diarize-jruby
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease:
+platform: java
+authors:
+- Yves Raimond
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: to-rdf
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: jblas-ruby
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :runtime
+description: A library for JRuby wrapping the LIUM Speaker Diarization and including a few extra tools
+email: yves.raimond@bbc.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- diarize-jruby.gemspec
+- lib/diarize.rb
+- lib/diarize/LIUM_SpkDiarization-4.2.jar
+- lib/diarize/lium.rb
+- lib/diarize/audio.rb
+- lib/diarize/audio_player.rb
+- lib/diarize/segmentation.rb
+- lib/diarize/segment.rb
+- lib/diarize/ubm.gmm
+- lib/diarize/speaker.rb
+- lib/diarize/super_vector.rb
+homepage: http://github.com/bbcrd/diarize
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: Speaker Diarization for JRuby
+test_files: []
+has_rdoc: false