Add Nn::ScaledLabelScorer and use it in Nn::CombineLabelScorer (#171)

Author: SimBe195

src/Nn/LabelScorer/CombineLabelScorer.cc

@@ -21,37 +21,34 @@ namespace Nn {
 Core::ParameterInt CombineLabelScorer::paramNumLabelScorers(
         "num-scorers", "Number of label scorers to combine", 1, 1);
 
-Core::ParameterFloat CombineLabelScorer::paramScale(
-        "scale", "Scores of a sub-label-scorer are scaled by this factor", 1.0);
-
 CombineLabelScorer::CombineLabelScorer(Core::Configuration const& config)
         : Core::Component(config),
           Precursor(config, TransitionPresetType::ALL) {
     size_t numLabelScorers = paramNumLabelScorers(config);
     for (size_t i = 0ul; i < numLabelScorers; ++i) {
         Core::Configuration subConfig = select(std::string("scorer-") + std::to_string(i + 1));
-        scaledScorers_.push_back({Nn::Module::instance().labelScorerFactory().createLabelScorer(subConfig), static_cast<Score>(paramScale(subConfig))});
+        scorers_.push_back(Nn::Module::instance().labelScorerFactory().createLabelScorer(subConfig));
     }
 }
 
 void CombineLabelScorer::reset() {
-    for (auto& scaledScorer : scaledScorers_) {
-        scaledScorer.scorer->reset();
+    for (auto& scorer : scorers_) {
+        scorer->reset();
     }
 }
 
 void CombineLabelScorer::signalNoMoreFeatures() {
-    for (auto& scaledScorer : scaledScorers_) {
-        scaledScorer.scorer->signalNoMoreFeatures();
+    for (auto& scorer : scorers_) {
+        scorer->signalNoMoreFeatures();
     }
 }
 
 ScoringContextRef CombineLabelScorer::getInitialScoringContext() {
     std::vector<ScoringContextRef> scoringContexts;
-    scoringContexts.reserve(scaledScorers_.size());
+    scoringContexts.reserve(scorers_.size());
 
-    for (const auto& scaledScorer : scaledScorers_) {
-        scoringContexts.push_back(scaledScorer.scorer->getInitialScoringContext());
+    for (const auto& scorer : scorers_) {
+        scoringContexts.push_back(scorer->getInitialScoringContext());
     }
     return Core::ref(new CombineScoringContext(std::move(scoringContexts)));
 }
@@ -63,41 +60,41 @@ void CombineLabelScorer::cleanupCaches(Core::CollapsedVector<ScoringContextRef>
         combineContexts.push_back(dynamic_cast<const CombineScoringContext*>(activeContext.get()));
     }
 
-    for (size_t scorerIdx = 0ul; scorerIdx < scaledScorers_.size(); ++scorerIdx) {
-        auto const&                              scaledScorer = scaledScorers_[scorerIdx];
+    for (size_t scorerIdx = 0ul; scorerIdx < scorers_.size(); ++scorerIdx) {
+        auto const&                              scorer = scorers_[scorerIdx];
         Core::CollapsedVector<ScoringContextRef> subScoringContexts;
         for (auto const& combineContext : combineContexts) {
             subScoringContexts.push_back(combineContext->scoringContexts[scorerIdx]);
         }
 
-        scaledScorer.scorer->cleanupCaches(subScoringContexts);
+        scorer->cleanupCaches(subScoringContexts);
     }
 }
 
 void CombineLabelScorer::addInput(DataView const& input) {
-    for (auto& scaledScorer : scaledScorers_) {
-        scaledScorer.scorer->addInput(input);
+    for (auto& scorer : scorers_) {
+        scorer->addInput(input);
     }
 }
 
 void CombineLabelScorer::addInputs(DataView const& input, size_t nTimesteps) {
-    for (auto& scaledScorer : scaledScorers_) {
-        scaledScorer.scorer->addInputs(input, nTimesteps);
+    for (auto& scorer : scorers_) {
+        scorer->addInputs(input, nTimesteps);
     }
 }
 
 ScoringContextRef CombineLabelScorer::extendedScoringContextInternal(Request const& request) {
     auto combineContext = dynamic_cast<const CombineScoringContext*>(request.context.get());
 
     std::vector<ScoringContextRef> extScoringContexts;
-    extScoringContexts.reserve(scaledScorers_.size());
+    extScoringContexts.reserve(scorers_.size());
 
-    auto scorerIt  = scaledScorers_.begin();
+    auto scorerIt  = scorers_.begin();
     auto contextIt = combineContext->scoringContexts.begin();
 
-    for (; scorerIt != scaledScorers_.end(); ++scorerIt, ++contextIt) {
+    for (; scorerIt != scorers_.end(); ++scorerIt, ++contextIt) {
         Request subRequest{*contextIt, request.nextToken, request.transitionType};
-        extScoringContexts.push_back(scorerIt->scorer->extendedScoringContext(subRequest));
+        extScoringContexts.push_back((*scorerIt)->extendedScoringContext(subRequest));
     }
     return Core::ref(new CombineScoringContext(std::move(extScoringContexts)));
 }
@@ -109,22 +106,22 @@ std::optional<LabelScorer::ScoreWithTime> CombineLabelScorer::computeScoreWithTi
     auto combineContext = dynamic_cast<const CombineScoringContext*>(request.context.get());
 
     // Iterate over all the scorers and accumulate their results into `accumResult`
-    auto scorerIt  = scaledScorers_.begin();
+    auto scorerIt  = scorers_.begin();
     auto contextIt = combineContext->scoringContexts.begin();
-    for (; scorerIt != scaledScorers_.end(); ++scorerIt, ++contextIt) {
+    for (; scorerIt != scorers_.end(); ++scorerIt, ++contextIt) {
         // Prepare sub-request for the current scorer by extracting the appropriate
         // ScoringContext from the combined ScoringContext
         Request subRequest{*contextIt, request.nextToken, request.transitionType};
 
         // Run current scorer
-        auto result = scorerIt->scorer->computeScoreWithTime(subRequest);
+        auto result = (*scorerIt)->computeScoreWithTime(subRequest);
         if (!result) {
             return {};
         }
 
         // Merge results of current scorer into `accumResult`
         // Scores are weighted sum, timeframes are maximum
-        accumResult.score += result->score * scorerIt->scale;
+        accumResult.score += result->score;
         accumResult.timeframe = std::max(accumResult.timeframe, result->timeframe);
     }
 
@@ -147,7 +144,7 @@ std::optional<LabelScorer::ScoresWithTimes> CombineLabelScorer::computeScoresWit
     }
 
     // Iterate over all the scorers and accumulate their results into `accumResult`
-    for (size_t scorerIdx = 0ul; scorerIdx < scaledScorers_.size(); ++scorerIdx) {
+    for (size_t scorerIdx = 0ul; scorerIdx < scorers_.size(); ++scorerIdx) {
         // Prepare sub-requests for the current scorer by extracting the appropriate
         // ScoringContext from all the CombineScoringContexts
         std::vector<Request> subRequests;
@@ -159,7 +156,7 @@ std::optional<LabelScorer::ScoresWithTimes> CombineLabelScorer::computeScoresWit
         }
 
         // Run current scorer
-        auto subResults = scaledScorers_[scorerIdx].scorer->computeScoresWithTimes(subRequests);
+        auto subResults = scorers_[scorerIdx]->computeScoresWithTimes(subRequests);
         if (!subResults) {
             return {};
         }
@@ -168,7 +165,7 @@ std::optional<LabelScorer::ScoresWithTimes> CombineLabelScorer::computeScoresWit
         // Scores are weighted sum, timeframes are maximum
         Core::CollapsedVector<Speech::TimeframeIndex> newTimeframes;
         for (size_t requestIdx = 0ul; requestIdx < requests.size(); ++requestIdx) {
-            accumResult.scores[requestIdx] += subResults->scores[requestIdx] * scaledScorers_[scorerIdx].scale;
+            accumResult.scores[requestIdx] += subResults->scores[requestIdx];
             newTimeframes.push_back(std::max(accumResult.timeframes[requestIdx], subResults->timeframes[requestIdx]));
         }
         accumResult.timeframes = newTimeframes;

src/Nn/LabelScorer/CombineLabelScorer.hh

@@ -31,8 +31,7 @@ class CombineLabelScorer : public LabelScorer {
     using Precursor = LabelScorer;
 
 public:
-    static Core::ParameterInt   paramNumLabelScorers;
-    static Core::ParameterFloat paramScale;
+    static Core::ParameterInt paramNumLabelScorers;
 
     CombineLabelScorer(const Core::Configuration& config);
     virtual ~CombineLabelScorer() = default;
@@ -56,12 +55,7 @@ public:
     virtual void addInputs(DataView const& input, size_t nTimesteps) override;
 
 protected:
-    struct ScaledLabelScorer {
-        Core::Ref<LabelScorer> scorer;
-        Score                  scale;
-    };
-
-    std::vector<ScaledLabelScorer> scaledScorers_;
+    std::vector<Core::Ref<LabelScorer>> scorers_;
 
     // Combine extended ScoringContexts from all sub-scorers
     ScoringContextRef extendedScoringContextInternal(Request const& request) override;

src/Nn/LabelScorer/LabelScorerFactory.cc

@@ -25,8 +25,9 @@ void LabelScorerFactory::registerLabelScorer(const char* name, CreationFunction
     registry_.push_back(std::move(creationFunction));
 }
 
-Core::Ref<LabelScorer> LabelScorerFactory::createLabelScorer(Core::Configuration const& config) const {
-    return registry_.at(paramLabelScorerType(config))(config);
+Core::Ref<ScaledLabelScorer> LabelScorerFactory::createLabelScorer(Core::Configuration const& config) const {
+    auto subScorer = registry_.at(paramLabelScorerType(config))(config);
+    return Core::ref(new ScaledLabelScorer(config, subScorer));
 }
 
 }  // namespace Nn

src/Nn/LabelScorer/LabelScorerFactory.hh

@@ -23,6 +23,7 @@
 #include <Core/ReferenceCounting.hh>
 
 #include "LabelScorer.hh"
+#include "ScaledLabelScorer.hh"
 
 namespace Nn {
 
@@ -49,9 +50,9 @@ public:
     void registerLabelScorer(const char* name, CreationFunction creationFunction);
 
     /*
-     * Create a LabelScorer instance of the type given by `paramLabelScorerType` using the config object
+     * Create a ScaledLabelScorer instance of the type given by `paramLabelScorerType` using the config object
      */
-    Core::Ref<LabelScorer> createLabelScorer(Core::Configuration const& config) const;
+    Core::Ref<ScaledLabelScorer> createLabelScorer(Core::Configuration const& config) const;
 
 private:
     typedef std::vector<CreationFunction> Registry;

src/Nn/LabelScorer/Makefile

@@ -21,6 +21,7 @@ LIBSPRINTLABELSCORER_O =  \
     $(OBJDIR)/FixedContextOnnxLabelScorer.o \
     $(OBJDIR)/NoContextOnnxLabelScorer.o \
     $(OBJDIR)/NoOpLabelScorer.o \
+    $(OBJDIR)/ScaledLabelScorer.o \
     $(OBJDIR)/ScoringContext.o \
     $(OBJDIR)/StatefulOnnxLabelScorer.o \
     $(OBJDIR)/TransitionLabelScorer.o

src/Nn/LabelScorer/ScaledLabelScorer.cc

@@ -0,0 +1,77 @@
+/** Copyright 2025 RWTH Aachen University. All rights reserved.
+ *
+ *  Licensed under the RWTH ASR License (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.hltpr.rwth-aachen.de/rwth-asr/rwth-asr-license.html
+ *
+ *  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.
+ */
+
+#include "ScaledLabelScorer.hh"
+
+namespace Nn {
+
+const Core::ParameterFloat ScaledLabelScorer::paramScale(
+        "scale",
+        "Scale to multiply the scores of the sub-scorer by.",
+        1.0);
+
+ScaledLabelScorer::ScaledLabelScorer(Core::Configuration const& config, Core::Ref<LabelScorer> const& scorer)
+        : Core::Component(config),
+          LabelScorer(config, TransitionPresetType::ALL),
+          scale_(paramScale(config)) {
+}
+
+void ScaledLabelScorer::reset() {
+    scorer_->reset();
+}
+
+void ScaledLabelScorer::signalNoMoreFeatures() {
+    scorer_->signalNoMoreFeatures();
+}
+
+ScoringContextRef ScaledLabelScorer::getInitialScoringContext() {
+    return scorer_->getInitialScoringContext();
+}
+
+void ScaledLabelScorer::cleanupCaches(Core::CollapsedVector<ScoringContextRef> const& activeContexts) {
+    scorer_->cleanupCaches(activeContexts);
+}
+
+void ScaledLabelScorer::addInput(DataView const& input) {
+    scorer_->addInput(input);
+}
+
+void ScaledLabelScorer::addInputs(DataView const& input, size_t nTimesteps) {
+    scorer_->addInputs(input, nTimesteps);
+}
+
+ScoringContextRef ScaledLabelScorer::extendedScoringContextInternal(Request const& request) {
+    return scorer_->extendedScoringContext(request);
+}
+
+std::optional<LabelScorer::ScoreWithTime> ScaledLabelScorer::computeScoreWithTimeInternal(Request const& request) {
+    auto result = scorer_->computeScoreWithTime(request);
+    if (result and scale_ != 1) {
+        result->score *= scale_;
+    }
+    return result;
+}
+
+std::optional<LabelScorer::ScoresWithTimes> ScaledLabelScorer::computeScoresWithTimesInternal(std::vector<LabelScorer::Request> const& requests) {
+    auto result = scorer_->computeScoresWithTimes(requests);
+    if (result and scale_ != 1) {
+        for (auto& score : result->scores) {
+            score *= scale_;
+        }
+    }
+    return result;
+}
+
+}  // namespace Nn

src/Nn/LabelScorer/ScaledLabelScorer.hh

@@ -0,0 +1,69 @@
+/** Copyright 2025 RWTH Aachen University. All rights reserved.
+ *
+ *  Licensed under the RWTH ASR License (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.hltpr.rwth-aachen.de/rwth-asr/rwth-asr-license.html
+ *
+ *  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.
+ */
+
+#ifndef SCALED_LABEL_SCORER_HH
+#define SCALED_LABEL_SCORER_HH
+
+#include <Core/Configuration.hh>
+
+#include "LabelScorer.hh"
+
+namespace Nn {
+
+/*
+ * Wraps a sub label scorer and scales all the scores by a given factor
+ */
+class ScaledLabelScorer : public LabelScorer {
+public:
+    static const Core::ParameterFloat paramScale;
+
+    ScaledLabelScorer(Core::Configuration const& config, Core::Ref<LabelScorer> const& scorer);
+
+    // Reset sub-scorer
+    void reset() override;
+
+    // Forward signal to sub-scorer
+    void signalNoMoreFeatures() override;
+
+    // Initial ScoringContext from sub-scorer
+    ScoringContextRef getInitialScoringContext() override;
+
+    // Cleanup sub-scorer
+    void cleanupCaches(Core::CollapsedVector<ScoringContextRef> const& activeContexts) override;
+
+    // Add input to sub-scorer
+    void addInput(DataView const& input) override;
+
+    // Add inputs to sub-scorer
+    virtual void addInputs(DataView const& input, size_t nTimesteps) override;
+
+protected:
+    // Extended ScoringContext from sub-scorer
+    ScoringContextRef extendedScoringContextInternal(Request const& request) override;
+
+    // Compute scaled score of request with sub-scorer
+    std::optional<ScoreWithTime> computeScoreWithTimeInternal(Request const& request) override;
+
+    // Compute scaled scores of requests with sub-scorer
+    std::optional<ScoresWithTimes> computeScoresWithTimesInternal(std::vector<Request> const& requests) override;
+
+private:
+    Core::Ref<LabelScorer> scorer_;
+    Score                  scale_;
+};
+
+}  // namespace Nn
+
+#endif  // SCALED_LABEL_SCORER_HH

src/Nn/Module.cc

@@ -23,6 +23,7 @@
 #include "LabelScorer/FixedContextOnnxLabelScorer.hh"
 #include "LabelScorer/NoContextOnnxLabelScorer.hh"
 #include "LabelScorer/NoOpLabelScorer.hh"
+#include "LabelScorer/ScaledLabelScorer.hh"
 #include "LabelScorer/StatefulOnnxLabelScorer.hh"
 #include "LabelScorer/TransitionLabelScorer.hh"
 #include "Statistics.hh"

src/Nn/Module.hh

@@ -23,7 +23,6 @@
 #include <Flow/Module.hh>
 
 #include "LabelScorer/EncoderFactory.hh"
-#include "LabelScorer/LabelScorer.hh"
 #include "LabelScorer/LabelScorerFactory.hh"
 
 namespace Core {
@@ -63,8 +62,6 @@ public:
      */
     LabelScorerFactory& labelScorerFactory();
 
-    Core::Ref<LabelScorer> createLabelScorer(const Core::Configuration& config) const;
-
 private:
     Core::FormatSet*   formats_;
     EncoderFactory     encoderFactory_;