Bausager/panic
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

model.cpp/hpp

Browse Source 
I made the model struct to store layers. I'm still missing the backward functions, but it's functional
This commit is contained in:
Bausager
2026-07-28 19:36:26 +02:00
parent 441540a996
commit c7e87fe191
10 changed files with 552 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/math/add.cpp
+1 -2
View File
@@ -51,8 +51,7 @@
* Small vectors and matrices are kept serial because the overhead of starting
* worker threads can be larger than the work itself.
*/
//static const panic::types::uint_t add_omp_min_work = 10000;
static const panic::types::uint_t add_omp_min_work = 0;
static const panic::types::uint_t add_omp_min_work = 500;
//---------------------------------------------------------------------------------------------------------------------------
// INPLEMENTATION
//---------------------------------------------------------------------------------------------------------------------------
src/math/mul.hpp
View File
src/neural_network/layer/layer_dense.cpp
+20 -28
View File
@@ -24,7 +24,7 @@
* Module Name: neural_network
* File Name: layer_dense.cpp
* Revision: 0.1.0
* Date: 23-06-2026
* Date: 28-07-2026
* Author: Michelle Bausager
*
* Description:
@@ -37,25 +37,25 @@
//---------------------------------------------------------------------------------------------------------------------------
#include <neural_network/layer/layer_dense.hpp>
#include <config/omp.hpp>
#include <math/matmul.hpp>
#include <math/add.hpp>
#include <random/uniform.hpp>
//---------------------------------------------------------------------------------------------------------------------------
// DEFINE DESCRIPTION
// PRIVATE CONSTANTS
//---------------------------------------------------------------------------------------------------------------------------
/**
* @brief Minimum number of element operations before using the OpenMP-enabled loop.
*
* Small vectors and matrices are kept serial because the overhead of starting
* worker threads can be larger than the work itself.
*/
static const panic::types::uint_t layer_dense_omp_min_size = 500;
//---------------------------------------------------------------------------------------------------------------------------
// INPLEMENTATION
//---------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------
// TYPE DESCRIPTION
//---------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------
// VARIABLE DESCRIPTION
//---------------------------------------------------------------------------------------------------------------------------
static const panic::types::uint_t layer_dense_omp_min_size = 10000;
//---------------------------------------------------------------------------------------------------------------------------
// FUNCTION PROTOTYPE
//---------------------------------------------------------------------------------------------------------------------------
namespace panic{
namespace neural_network{
@@ -76,27 +76,19 @@ layer_dense::layer_dense() {
// Constructor Name : panic::neural_network::layer_dense
//
// Description:
// Creates an empty layer.
// Creates an empty layer with neurons.
//--------------------------------------------------------------------------------------------------------------------------
layer_dense::layer_dense(panic::types::uint_t input_size, panic::types::uint_t neurons) {
weights.resize(input_size, neurons);
panic::random::uniform(weights);
//panic::math::matmul(weights, 0.01f);
biases.resize(neurons);
panic::random::uniform(biases);
outputs.resize(0,0);
}
//--------------------------------------------------------------------------------------------------------------------------
// Deconstructor Name : panic::tensor::vector::~vector
//
// Description:
// Deletes the data and releases the memory.
//--------------------------------------------------------------------------------------------------------------------------
//template <typename T>
//vector<T>::~vector(){
// delete[] data;
//
// data = 0;
// length = 0;
//}
//--------------------------------------------------------------------------------------------------------------------------
// Function Name : panic::neural_network::layer_dense.forward
src/neural_network/model/model.cpp
+234
View File
@@ -0,0 +1,234 @@
/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
*
* PANIC
* Portable Algorithms and Numerics In C++
*
* Scientific computing from scratch, with feeling.
*
* Copyright (c) 2026 Michelle Bausager
*
* This file is part of PANIC.
*
* PANIC is free software licensed under the GNU General Public License v3.0 or later.
* You may redistribute and/or modify it under the terms of the GPL.
*
* PANIC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the LICENSE file for the full license text.
*
* SPDX-License-Identifier: GPL-3.0-or-later
*
*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
*
* Project Name: PANIC
* Module Name: neural_network
* File Name: model.cpp
* Revision: 0.1.0
* Date: 25-06-2026
* Author: Michelle Bausager
*
* Description:
* Defines the base model struct used in in neural network
*
*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
//---------------------------------------------------------------------------------------------------------------------------
// INCLUDE DESCRIPTION
//---------------------------------------------------------------------------------------------------------------------------
#include <neural_network/model/model.hpp>
#include <config/types.hpp>
#include <tensor/vector.hpp>
#include <tensor/matrix.hpp>
//---------------------------------------------------------------------------------------------------------------------------
// IMPLEMENTATION
//---------------------------------------------------------------------------------------------------------------------------
namespace panic{
namespace neural_network{
//--------------------------------------------------------------------------------------------------------------------------
// Constructor Name : panic::neural_network::model
//
// Description:
// Creates an empty model.
//--------------------------------------------------------------------------------------------------------------------------
model::model(){
// No layers yet.
layers = 0;
// Number of layers is zero.
layer_count = 0;
}
//--------------------------------------------------------------------------------------------------------------------------
// Destructor Name : panic::neural_network::model::~model
//
// Description:
// Deletes all layers owned by the model.
//--------------------------------------------------------------------------------------------------------------------------
model::~model(){
clear();
}
//--------------------------------------------------------------------------------------------------------------------------
// Function Name : panic::neural_network::model::add
//
// Description:
// Adds a layer to the model.
//
// The layer pointer array
// is resized every time a new layer is added.
//--------------------------------------------------------------------------------------------------------------------------
bool model::add(layer* new_layer){
// Do not add a null layer.
if (new_layer == 0){
return false;
}
// The new array needs room for all old layers plus the new one.
const panic::types::uint_t new_layer_count = layer_count + 1;
// Allocate a new array of layer pointers.
//
// layer* means "pointer to one layer"
// layer** means "pointer to many layer pointers"
//
// So this creates:
//
// [ layer* ][ layer* ][ layer* ] ...
//
layer** new_layers = new layer*[new_layer_count];
// Copy the old layer pointers into the new array.
//
// Important:
// This does not copy the layers themselves.
// It only copies the addresses of the layers.
for (panic::types::uint_t i = 0; i < layer_count; ++i){
new_layers[i] = layers[i];
}
// Put the new layer at the end.
new_layers[layer_count] = new_layer;
// Delete the old array of pointers.
//
// Important:
// Do NOT delete layers[i] here.
// The actual layer objects are still used in new_layers.
//
// This only deletes the old pointer array.
delete[] layers;
// Make the model use the new bigger array.
layers = new_layers;
// Update the layer count.
layer_count = new_layer_count;
return true;
}
//--------------------------------------------------------------------------------------------------------------------------
// Function Name : panic::neural_network::model::add_layer_dense
//
// Description:
// Creates a dense layer and adds it to the model.
//
// Example:
// model.add_dense(100, 64);
//--------------------------------------------------------------------------------------------------------------------------
bool model::add_layer_dense(
panic::types::uint_t input_size,
panic::types::uint_t neuron_count){
// Create the dense layer.
layer_dense* new_layer = new layer_dense(input_size, neuron_count);
if (new_layer == 0){
return false;
}
// Add it to the model.
//
// If add() fails, delete the layer so we do not leak memory.
if (!add(new_layer)){
delete new_layer;
return false;
}
return true;
}
//--------------------------------------------------------------------------------------------------------------------------
// Function Name : panic::neural_network::model::forward
//
// Description:
// Runs the input through every layer in order.
//--------------------------------------------------------------------------------------------------------------------------
bool model::forward(const panic::tensor::real_matrix& inputs){
// If the model has no layers, just copy inputs to outputs.
if (layer_count == 0){
outputs = inputs;
return true;
}
// First layer receives the original model input.
if (!layers[0]->forward(inputs)){
return false;
}
// Every next layer receives the output from the previous layer.
// If it fails, return false
for (panic::types::uint_t i = 1; i < layer_count; ++i){
if (!layers[i]->forward(layers[i - 1] -> outputs)){
return false;
}
}
// The model output is the output of the last layer.
outputs = layers[layer_count - 1] -> outputs;
return true;
}
//--------------------------------------------------------------------------------------------------------------------------
// Function Name : panic::neural_network::model::clear
//
// Description:
// Deletes all layers and resets the model.
//--------------------------------------------------------------------------------------------------------------------------
void model::clear(){
if (layers != 0){
// Delete each actual layer object.
for (panic::types::uint_t i = 0; i < layer_count; ++i){
delete layers[i];
layers[i] = 0;
}
// Delete the array that stored the layer pointers.
delete[] layers;
}
// Reset to empty state.
layers = 0;
layer_count = 0;
outputs.resize(0, 0);
}
} // namespace neural_network
} // namespace panic