LinearModel.cpp

Go to the documentation of this file.

 
#include "LinearModel.h"
 
namespace krotos
{
 
    LinearModel::LinearModel(const std::vector<Eigen::MatrixXf>& weights, const std::vector<Eigen::VectorXf>& biases,
                             const Eigen::MatrixXf& weightsOutput, const Eigen::VectorXf& biasOutput,
                             const StringArray& categories)
        : m_weights(weights), m_bias(biases), m_weightsOutput(weightsOutput), m_biasOutput(biasOutput),
          m_outputCategories(categories)
    {
        // get number of layers
        m_numLayers = m_weights.size();
 
        // get the size of each layer
        m_layerSize = m_weights[0].rows();
 
        // resize layer outputs
        m_layerOutput.resize(m_numLayers);
 
        for (auto& layerOut : m_layerOutput)
        {
            layerOut.resize(m_layerSize);
        }
        // resize outputs to the size of output categories
        m_outputs.resize(categories.size());
 
        // resize working buffer
        m_workingBuffer.resize(m_layerSize);
    }
 
LinearModel::LinearModel() { loadModelData(); }
 
Eigen::VectorXf LinearModel::infer(const Eigen::VectorXf& input)
{
    // input should be same size as the input layer weights
    jassert(input.size() == m_layerSize);
 
    // add activation here if needed (use working buffer):
    m_workingBuffer = m_weights[0].transpose() * input + m_bias[0];
    m_layerOutput[0] = relu(m_workingBuffer);
 
    for (int i = 1; i < m_numLayers; i++)
    {
        m_layerOutput[i] = m_weights[0] * m_layerOutput[i - 1] + m_bias[i];
    }
 
    // // calculate output layer
    m_workingBuffer = m_weightsOutput * m_layerOutput[m_numLayers - 1] + m_biasOutput;
 
    // apply activation
    m_outputs = sigmoid(m_workingBuffer);
 
    // get index of the max element
    auto maxElementIter = std::max_element(m_outputs.data(), m_outputs.data() + m_outputs.size());
    int maxIdx = std::distance(m_outputs.data(), maxElementIter);
 
    m_prominentCategoryIndex = maxIdx;
 
    return m_outputs;
}
 
Eigen::VectorXf LinearModel::inferSingle(const Eigen::VectorXf& input)
{
    // input should be same size as the input layer weights
    jassert(input.size() == m_layerSize);
 
    m_workingBuffer = m_weights[0] * input + m_bias[0];
    m_outputs = sigmoid(m_workingBuffer);
 
    // get index of the max element
    auto maxElementIter = std::max_element(m_outputs.data(), m_outputs.data() + m_outputs.size());
    int maxIdx = std::distance(m_outputs.data(), maxElementIter);
 
    m_prominentCategoryIndex = maxIdx;
 
    return m_outputs;
}
 
void LinearModel::loadModelData()
{
    // load json from binary data
    const char* jsonBinaryData = reinterpret_cast<const char*>(KrotosBinaryData::logistic_regression_json);
 
    // convert to string
    String jsonString(jsonBinaryData);
 
    // and parse it
    auto parsedData = JSON::parse(jsonString);
 
    if (!parsedData.isVoid())
    {
        auto* object = parsedData.getDynamicObject();
 
        // keep weights in a var
        Array<var> weightsAllLayers;
        Array<var> biasesAllLayers;
 
        // keys for bias and weights
        StringArray weightKeys;
        StringArray biasKeys;
 
        // iterate to get layer key
        for (auto& prop : object->getProperties())
        {
            // property name to string
            String propertyName = prop.name.toString();
            if (propertyName.contains("weight"))
            {
                weightKeys.add(propertyName);
            }
            else if (propertyName.contains("bias"))
            {
                biasKeys.add(propertyName);
            }
        }
 
        // the number of layers is equal to the weight keys size
        m_numLayers = weightKeys.size();
 
        // load weights and biases for each layer
        for (auto& weightLayerName : weightKeys)
        {
            // array to keep the current layer from json data
            m_weightsVar = object->getProperty(weightLayerName);
 
            if (m_weightsVar.isArray())
            {
                weightsAllLayers.add(m_weightsVar);
            }
        }
 
        // load biases for each layer
        for (auto& biasLayerName : biasKeys)
        {
            // array to keep the current layer from json data
            juce::var bias = object->getProperty(biasLayerName);
 
            if (bias.isArray())
            {
                // get size
                int biasVecSize = bias.size();
 
                // the temporary eigen vector
                Eigen::VectorXf biasVec(biasVecSize);
                for (int i = 0; i < biasVecSize; i++)
                {
                    biasVec[i] = bias[i];
                }
                // add to m_bias
                m_bias.push_back(biasVec);
            }
        }
 
        // Weights ..
        for (const auto& weights : weightsAllLayers)
        {
            if (weights.isArray())
            {
                // convert to eigen representations and pass it to member variable
                int numRows = weights.getArray()->size();
                int numCols = weights.getArray()->begin()->getArray()->size();
                if (numCols == 0 || numRows == 0)
                {
                    continue;
                }
                m_layerSize = numCols;
                // Create an Eigen matrix with the appropriate size
                Eigen::MatrixXf weightsMatrix(numRows, numCols);
                for (int i = 0; i < numRows; i++)
                {
                    for (int j = 0; j < numCols; j++)
                    {
                        weightsMatrix(i, j) =
                                static_cast<double>(weights.getArray()->getUnchecked(i).getArray()->getUnchecked(j));
                    }
                }
                // // and push it back to m_weights
                m_weights.push_back(weightsMatrix);
            }
        }
 
        // get categories
        auto categories = object->getProperty("classes");
        for (auto& cat : *categories.getArray())
        {
            m_outputCategories.add(cat.toString());
        }
    }
}
 
StringArray LinearModel::getOutputCategories()
{
    return m_outputCategories;
}
 
Eigen::VectorXf LinearModel::sigmoid(const Eigen::VectorXf& lOut) { return 1.0 / (1.0 + (-lOut.array()).exp()); }
 
Eigen::VectorXf LinearModel::relu(const Eigen::VectorXf& lOut) { return lOut.array().max(0.0); }
 
String LinearModel::getProminentCategory() 
{
    return m_outputCategories[m_prominentCategoryIndex];
}
 
 
} // namespace krotos