diff --git a/source/use_case/kws_asr/src/AsrClassifier.cc b/source/use_case/kws_asr/src/AsrClassifier.cc
index 57d5058..3f9cd7b 100644
--- a/source/use_case/kws_asr/src/AsrClassifier.cc
+++ b/source/use_case/kws_asr/src/AsrClassifier.cc
@@ -73,8 +73,9 @@
 bool arm::app::AsrClassifier::GetClassificationResults(
             TfLiteTensor* outputTensor,
             std::vector<ClassificationResult>& vecResults,
-            const std::vector <std::string>& labels, uint32_t topNCount)
+            const std::vector <std::string>& labels, uint32_t topNCount, bool use_softmax)
 {
+        UNUSED(use_softmax);
         vecResults.clear();
 
         constexpr int minTensorDims = static_cast<int>(
diff --git a/source/use_case/kws_asr/src/MainLoop.cc b/source/use_case/kws_asr/src/MainLoop.cc
index d5a2c2b..30cb084 100644
--- a/source/use_case/kws_asr/src/MainLoop.cc
+++ b/source/use_case/kws_asr/src/MainLoop.cc
@@ -16,11 +16,11 @@
  */
 #include "hal.h"                    /* Brings in platform definitions. */
 #include "InputFiles.hpp"           /* For input images. */
-#include "Labels_dscnn.hpp"         /* For DS-CNN label strings. */
+#include "Labels_micronetkws.hpp"   /* For MicroNetKws label strings. */
 #include "Labels_wav2letter.hpp"    /* For Wav2Letter label strings. */
 #include "Classifier.hpp"           /* KWS classifier. */
 #include "AsrClassifier.hpp"        /* ASR classifier. */
-#include "DsCnnModel.hpp"           /* KWS model class for running inference. */
+#include "MicroNetKwsModel.hpp"     /* KWS model class for running inference. */
 #include "Wav2LetterModel.hpp"      /* ASR model class for running inference. */
 #include "UseCaseCommonUtils.hpp"   /* Utils functions. */
 #include "UseCaseHandler.hpp"       /* Handlers for different user options. */
@@ -69,7 +69,7 @@
 void main_loop(hal_platform& platform)
 {
     /* Model wrapper objects. */
-    arm::app::DsCnnModel kwsModel;
+    arm::app::MicroNetKwsModel kwsModel;
     arm::app::Wav2LetterModel asrModel;
 
     /* Load the models. */
@@ -81,7 +81,7 @@
     /* Initialise the asr model using the same allocator from KWS
      * to re-use the tensor arena. */
     if (!asrModel.Init(kwsModel.GetAllocator())) {
-        printf_err("Failed to initalise ASR model\n");
+        printf_err("Failed to initialise ASR model\n");
         return;
     }
 
@@ -137,7 +137,7 @@
     caseContext.Set<const std::vector <std::string>&>("kwslabels", kwsLabels);
 
     /* Index of the kws outputs we trigger ASR on. */
-    caseContext.Set<uint32_t>("keywordindex", 2);
+    caseContext.Set<uint32_t>("keywordindex", 9 );
 
     /* Loop. */
     bool executionSuccessful = true;
diff --git a/source/use_case/kws_asr/src/DsCnnModel.cc b/source/use_case/kws_asr/src/MicroNetKwsModel.cc
similarity index 81%
rename from source/use_case/kws_asr/src/DsCnnModel.cc
rename to source/use_case/kws_asr/src/MicroNetKwsModel.cc
index 71d4ceb..4b44580 100644
--- a/source/use_case/kws_asr/src/DsCnnModel.cc
+++ b/source/use_case/kws_asr/src/MicroNetKwsModel.cc
@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "DsCnnModel.hpp"
+#include "MicroNetKwsModel.hpp"
 
 #include "hal.h"
 
@@ -27,21 +27,18 @@
 } /* namespace app */
 } /* namespace arm */
 
-const tflite::MicroOpResolver& arm::app::DsCnnModel::GetOpResolver()
+const tflite::MicroOpResolver& arm::app::MicroNetKwsModel::GetOpResolver()
 {
     return this->m_opResolver;
 }
 
-bool arm::app::DsCnnModel::EnlistOperations()
+bool arm::app::MicroNetKwsModel::EnlistOperations()
 {
     this->m_opResolver.AddAveragePool2D();
     this->m_opResolver.AddConv2D();
     this->m_opResolver.AddDepthwiseConv2D();
     this->m_opResolver.AddFullyConnected();
     this->m_opResolver.AddRelu();
-    this->m_opResolver.AddSoftmax();
-    this->m_opResolver.AddQuantize();
-    this->m_opResolver.AddDequantize();
     this->m_opResolver.AddReshape();
 
 #if defined(ARM_NPU)
@@ -56,12 +53,12 @@
     return true;
 }
 
-const uint8_t* arm::app::DsCnnModel::ModelPointer()
+const uint8_t* arm::app::MicroNetKwsModel::ModelPointer()
 {
     return arm::app::kws::GetModelPointer();
 }
 
-size_t arm::app::DsCnnModel::ModelSize()
+size_t arm::app::MicroNetKwsModel::ModelSize()
 {
     return arm::app::kws::GetModelLen();
 }
\ No newline at end of file
diff --git a/source/use_case/kws_asr/src/UseCaseHandler.cc b/source/use_case/kws_asr/src/UseCaseHandler.cc
index 1d88ba1..c67be22 100644
--- a/source/use_case/kws_asr/src/UseCaseHandler.cc
+++ b/source/use_case/kws_asr/src/UseCaseHandler.cc
@@ -20,8 +20,8 @@
 #include "InputFiles.hpp"
 #include "AudioUtils.hpp"
 #include "UseCaseCommonUtils.hpp"
-#include "DsCnnModel.hpp"
-#include "DsCnnMfcc.hpp"
+#include "MicroNetKwsModel.hpp"
+#include "MicroNetKwsMfcc.hpp"
 #include "Classifier.hpp"
 #include "KwsResult.hpp"
 #include "Wav2LetterMfcc.hpp"
@@ -77,12 +77,12 @@
      *
      * @param[in]           mfcc            MFCC feature calculator.
      * @param[in,out]       inputTensor     Input tensor pointer to store calculated features.
-     * @param[in]            cacheSize      Size of the feture vectors cache (number of feature vectors).
+     * @param[in]           cacheSize       Size of the feature vectors cache (number of feature vectors).
      *
      * @return function     function to be called providing audio sample and sliding window index.
      **/
     static std::function<void (std::vector<int16_t>&, int, bool, size_t)>
-    GetFeatureCalculator(audio::DsCnnMFCC&  mfcc,
+    GetFeatureCalculator(audio::MicroNetMFCC&  mfcc,
                          TfLiteTensor*      inputTensor,
                          size_t             cacheSize);
 
@@ -98,8 +98,8 @@
         constexpr uint32_t dataPsnTxtInfStartY = 40;
 
         constexpr int minTensorDims = static_cast<int>(
-            (arm::app::DsCnnModel::ms_inputRowsIdx > arm::app::DsCnnModel::ms_inputColsIdx)?
-             arm::app::DsCnnModel::ms_inputRowsIdx : arm::app::DsCnnModel::ms_inputColsIdx);
+            (arm::app::MicroNetKwsModel::ms_inputRowsIdx > arm::app::MicroNetKwsModel::ms_inputColsIdx)?
+             arm::app::MicroNetKwsModel::ms_inputRowsIdx : arm::app::MicroNetKwsModel::ms_inputColsIdx);
 
         KWSOutput output;
 
@@ -128,7 +128,7 @@
         const uint32_t kwsNumMfccFeats = ctx.Get<uint32_t>("kwsNumMfcc");
         const uint32_t kwsNumAudioWindows = ctx.Get<uint32_t>("kwsNumAudioWins");
 
-        audio::DsCnnMFCC kwsMfcc = audio::DsCnnMFCC(kwsNumMfccFeats, kwsFrameLength);
+        audio::MicroNetMFCC kwsMfcc = audio::MicroNetMFCC(kwsNumMfccFeats, kwsFrameLength);
         kwsMfcc.Init();
 
         /* Deduce the data length required for 1 KWS inference from the network parameters. */
@@ -152,7 +152,7 @@
 
         /* We expect to be sampling 1 second worth of data at a time
          * NOTE: This is only used for time stamp calculation. */
-        const float kwsAudioParamsSecondsPerSample = 1.0/audio::DsCnnMFCC::ms_defaultSamplingFreq;
+        const float kwsAudioParamsSecondsPerSample = 1.0/audio::MicroNetMFCC::ms_defaultSamplingFreq;
 
         auto currentIndex = ctx.Get<uint32_t>("clipIndex");
 
@@ -230,7 +230,7 @@
 
             kwsClassifier.GetClassificationResults(
                             kwsOutputTensor, kwsClassificationResult,
-                            ctx.Get<std::vector<std::string>&>("kwslabels"), 1);
+                            ctx.Get<std::vector<std::string>&>("kwslabels"), 1, true);
 
             kwsResults.emplace_back(
                 kws::KwsResult(
@@ -604,7 +604,7 @@
 
 
     static std::function<void (std::vector<int16_t>&, int, bool, size_t)>
-    GetFeatureCalculator(audio::DsCnnMFCC& mfcc, TfLiteTensor* inputTensor, size_t cacheSize)
+    GetFeatureCalculator(audio::MicroNetMFCC& mfcc, TfLiteTensor* inputTensor, size_t cacheSize)
     {
         std::function<void (std::vector<int16_t>&, size_t, bool, size_t)> mfccFeatureCalc;