Skip to content
Snippets Groups Projects
Commit df4e4fc1 authored by Cyril Moineau's avatar Cyril Moineau Committed by Maxence Naud
Browse files

Move filler definition in cpp files.

parent 8b9e1b9a
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
include/aidge/filler/Filler.hpp
+ 8
− 163
View file @ df4e4fc1
...@@ -19,8 +19,8 @@ ...@@ -19,8 +19,8 @@
namespace Aidge { namespace Aidge {
void calculateFanInFanOut(std::shared_ptr<Tensor> tensor, unsigned int& fanIn, inline void calculateFanInFanOut(std::shared_ptr<Tensor> tensor,
unsigned int& fanOut) { unsigned int& fanIn, unsigned int& fanOut) {
AIDGE_ASSERT( AIDGE_ASSERT(
tensor->nbDims() == 4, tensor->nbDims() == 4,
"Tensor need to have 4 dimensions to compute FanIn and FanOut."); "Tensor need to have 4 dimensions to compute FanIn and FanOut.");
...@@ -39,182 +39,27 @@ void calculateFanInFanOut(std::shared_ptr<Tensor> tensor, unsigned int& fanIn, ...@@ -39,182 +39,27 @@ void calculateFanInFanOut(std::shared_ptr<Tensor> tensor, unsigned int& fanIn,
enum VarianceNorm { FanIn, Average, FanOut }; enum VarianceNorm { FanIn, Average, FanOut };
template <typename T> template <typename T>
void constantFiller(std::shared_ptr<Tensor> tensor, T constantValue) { void constantFiller(std::shared_ptr<Tensor> tensor, T constantValue);
AIDGE_ASSERT(tensor->getImpl(),
"Tensor got no implementation, cannot fill it.");
AIDGE_ASSERT(NativeType<T>::type == tensor->dataType(), "Wrong data type");
std::shared_ptr<Tensor> cpyTensor;
// Create cpy only if tensor not on CPU
Tensor& tensorWithValues =
tensor->refCastFrom(cpyTensor, tensor->dataType(), "cpu");
// Setting values
for (std::size_t idx = 0; idx < tensorWithValues.size(); ++idx) {
tensorWithValues.set<T>(idx, constantValue);
}
// Copy values back to the original tensors (actual copy only if needed)
tensor->copyCastFrom(tensorWithValues);
}
// TODO: Keep template or use switch case depending on Tensor datatype ? // TODO: Keep template or use switch case depending on Tensor datatype ?
template <typename T> template <typename T>
void normalFiller(std::shared_ptr<Tensor> tensor, double mean = 0.0, void normalFiller(std::shared_ptr<Tensor> tensor, double mean = 0.0,
double stdDev = 1.0) { double stdDev = 1.0);
AIDGE_ASSERT(tensor->getImpl(),
"Tensor got no implementation, cannot fill it.");
AIDGE_ASSERT(NativeType<T>::type == tensor->dataType(), "Wrong data type");
std::random_device rd;
std::mt19937 gen(rd()); // Mersenne Twister pseudo-random number generator
std::normal_distribution<T> normalDist(mean, stdDev);
std::shared_ptr<Tensor> cpyTensor;
// Create cpy only if tensor not on CPU
Tensor& tensorWithValues =
tensor->refCastFrom(cpyTensor, tensor->dataType(), "cpu");
// Setting values
for (std::size_t idx = 0; idx < tensorWithValues.size(); ++idx) {
tensorWithValues.set<T>(idx, normalDist(gen));
}
// Copy values back to the original tensors (actual copy only if needed)
tensor->copyCastFrom(tensorWithValues);
};
// TODO: Keep template or use switch case depending on Tensor datatype ? // TODO: Keep template or use switch case depending on Tensor datatype ?
template <typename T> template <typename T>
void uniformFiller(std::shared_ptr<Tensor> tensor, T min, T max) { void uniformFiller(std::shared_ptr<Tensor> tensor, T min, T max);
AIDGE_ASSERT(tensor->getImpl(),
"Tensor got no implementation, cannot fill it.");
AIDGE_ASSERT(NativeType<T>::type == tensor->dataType(), "Wrong data type");
std::random_device rd;
std::mt19937 gen(rd()); // Mersenne Twister pseudo-random number generator
std::uniform_real_distribution<T> uniformDist(min, max);
std::shared_ptr<Tensor> cpyTensor;
// Create cpy only if tensor not on CPU
Tensor& tensorWithValues =
tensor->refCastFrom(cpyTensor, tensor->dataType(), "cpu");
// Setting values
for (std::size_t idx = 0; idx < tensorWithValues.size(); ++idx) {
tensorWithValues.set<T>(idx, uniformDist(gen));
}
// Copy values back to the original tensors (actual copy only if needed)
tensor->copyCastFrom(tensorWithValues);
};
template <typename T> template <typename T>
void xavierUniformFiller(std::shared_ptr<Tensor> tensor, T scaling = 1.0, void xavierUniformFiller(std::shared_ptr<Tensor> tensor, T scaling = 1.0,
VarianceNorm varianceNorm = FanIn) { VarianceNorm varianceNorm = FanIn);
AIDGE_ASSERT(tensor->getImpl(),
"Tensor got no implementation, cannot fill it.");
AIDGE_ASSERT(NativeType<T>::type == tensor->dataType(), "Wrong data type");
unsigned int fanIn, fanOut = 0;
calculateFanInFanOut(tensor, fanIn, fanOut);
const T n((varianceNorm == FanIn) ? fanIn
: (varianceNorm == Average) ? (fanIn + fanOut) / 2.0
: fanOut);
const T scale(std::sqrt(3.0 / n));
std::random_device rd;
std::mt19937 gen(rd()); // Mersenne Twister pseudo-random number generator
std::uniform_real_distribution<T> uniformDist(-scale, scale);
std::shared_ptr<Tensor> cpyTensor;
// Create cpy only if tensor not on CPU
Tensor& tensorWithValues =
tensor->refCastFrom(cpyTensor, tensor->dataType(), "cpu");
// Setting values
for (std::size_t idx = 0; idx < tensorWithValues.size(); ++idx) {
T value = scaling * uniformDist(gen);
tensorWithValues.set<T>(idx, value);
}
// Copy values back to the original tensors (actual copy only if needed)
tensor->copyCastFrom(tensorWithValues);
};
template <typename T> template <typename T>
void xavierNormalFiller(std::shared_ptr<Tensor> tensor, T scaling = 1.0, void xavierNormalFiller(std::shared_ptr<Tensor> tensor, T scaling = 1.0,
VarianceNorm varianceNorm = FanIn) { VarianceNorm varianceNorm = FanIn);
AIDGE_ASSERT(tensor->getImpl(),
"Tensor got no implementation, cannot fill it.");
AIDGE_ASSERT(NativeType<T>::type == tensor->dataType(), "Wrong data type");
unsigned int fanIn, fanOut = 0;
calculateFanInFanOut(tensor, fanIn, fanOut);
const T n((varianceNorm == FanIn) ? fanIn
: (varianceNorm == Average) ? (fanIn + fanOut) / 2.0
: fanOut);
const double stdDev(std::sqrt(1.0 / n));
std::random_device rd;
std::mt19937 gen(rd()); // Mersenne Twister pseudo-random number generator
std::normal_distribution<T> normalDist(0.0, stdDev);
std::shared_ptr<Tensor> cpyTensor;
// Create cpy only if tensor not on CPU
Tensor& tensorWithValues =
tensor->refCastFrom(cpyTensor, tensor->dataType(), "cpu");
// Setting values
for (std::size_t idx = 0; idx < tensorWithValues.size(); ++idx) {
tensorWithValues.set<T>(idx, normalDist(gen));
}
// Copy values back to the original tensors (actual copy only if needed)
tensor->copyCastFrom(tensorWithValues);
};
template <typename T> template <typename T>
void heFiller(std::shared_ptr<Tensor> tensor, VarianceNorm varianceNorm = FanIn, void heFiller(std::shared_ptr<Tensor> tensor, VarianceNorm varianceNorm = FanIn,
T meanNorm = 0.0, T scaling = 1.0) { T meanNorm = 0.0, T scaling = 1.0);
AIDGE_ASSERT(tensor->getImpl(),
"Tensor got no implementation, cannot fill it.");
AIDGE_ASSERT(NativeType<T>::type == tensor->dataType(), "Wrong data type");
unsigned int fanIn, fanOut = 0;
calculateFanInFanOut(tensor, fanIn, fanOut);
const T n((varianceNorm == FanIn) ? fanIn
: (varianceNorm == Average) ? (fanIn + fanOut) / 2.0
: fanOut);
const T stdDev(std::sqrt(2.0 / n));
const T mean(varianceNorm == FanIn ? meanNorm / fanIn
: (varianceNorm == Average)
? meanNorm / ((fanIn + fanOut) / 2.0)
: meanNorm / fanOut);
std::random_device rd;
std::mt19937 gen(rd()); // Mersenne Twister pseudo-random number generator
std::normal_distribution<T> normalDist(mean, stdDev);
std::shared_ptr<Tensor> cpyTensor;
// Create cpy only if tensor not on CPU
Tensor& tensorWithValues =
tensor->refCastFrom(cpyTensor, tensor->dataType(), "cpu");
// Setting values
for (std::size_t idx = 0; idx < tensorWithValues.size(); ++idx) {
tensorWithValues.set<T>(idx, normalDist(gen));
}
// Copy values back to the original tensors (actual copy only if needed)
tensor->copyCastFrom(tensorWithValues);
};
} // namespace Aidge } // namespace Aidge
#endif /* AIDGE_CORE_FILLER_H_ */ #endif /* AIDGE_CORE_FILLER_H_ */
python_binding/filler/pybind_Filler.cpp
+ 3
− 24
View file @ df4e4fc1
...@@ -35,29 +35,6 @@ void init_Filler(py::module &m) { ...@@ -35,29 +35,6 @@ void init_Filler(py::module &m) {
case DataType::Float32: case DataType::Float32:
constantFiller<float>(tensor, value.cast<float>()); constantFiller<float>(tensor, value.cast<float>());
break; break;
case DataType::Int8:
constantFiller<int8_t>(tensor, value.cast<int8_t>());
break;
case DataType::Int16:
constantFiller<std::int16_t>(tensor,
value.cast<std::int16_t>());
break;
case DataType::Int32:
constantFiller<std::int32_t>(tensor,
value.cast<std::int32_t>());
break;
case DataType::Int64:
constantFiller<std::int64_t>(tensor,
value.cast<std::int64_t>());
break;
case DataType::UInt8:
constantFiller<std::uint8_t>(tensor,
value.cast<std::uint8_t>());
break;
case DataType::UInt16:
constantFiller<std::uint16_t>(tensor,
value.cast<std::uint16_t>());
break;
default: default:
AIDGE_THROW_OR_ABORT( AIDGE_THROW_OR_ABORT(
py::value_error, py::value_error,
...@@ -163,6 +140,8 @@ void init_Filler(py::module &m) { ...@@ -163,6 +140,8 @@ void init_Filler(py::module &m) {
"Data type is not supported for Uniform filler."); "Data type is not supported for Uniform filler.");
} }
}, },
py::arg("tensor"), py::arg("varianceNorm") = VarianceNorm::FanIn, py::arg("meanNorm") = 0.0, py::arg("scaling") = 1.0); py::arg("tensor"), py::arg("varianceNorm") = VarianceNorm::FanIn,
py::arg("meanNorm") = 0.0, py::arg("scaling") = 1.0)
;
} }
} // namespace Aidge } // namespace Aidge
src/filler/ConstantFiller.cpp
+ 40
− 32
View file @ df4e4fc1
// /******************************************************************************** /********************************************************************************
// * Copyright (c) 2023 CEA-List * Copyright (c) 2023 CEA-List
// * *
// * This program and the accompanying materials are made available under the * This program and the accompanying materials are made available under the
// * terms of the Eclipse Public License 2.0 which is available at * terms of the Eclipse Public License 2.0 which is available at
// * http://www.eclipse.org/legal/epl-2.0. * http://www.eclipse.org/legal/epl-2.0.
// * *
// * SPDX-License-Identifier: EPL-2.0 * SPDX-License-Identifier: EPL-2.0
// * *
// ********************************************************************************/ ********************************************************************************/
#include <memory>
// #include "aidge/filler/Filler.hpp" #include <random> // normal_distribution, uniform_real_distribution
// template<typename T> #include "aidge/filler/Filler.hpp"
// void Aidge::constantFiller(std::shared_ptr<Aidge::Tensor> tensor, T constantValue){ #include "aidge/data/Tensor.hpp"
// AIDGE_ASSERT(tensor->getImpl(), "Tensor got no implementation, cannot fill it.");
// AIDGE_ASSERT(NativeType<T>::type == tensor->dataType(), "Wrong data type");
template<typename T>
// std::shared_ptr<Tensor> cpyTensor; void Aidge::constantFiller(std::shared_ptr<Aidge::Tensor> tensor, T constantValue){
// // Create cpy only if tensor not on CPU AIDGE_ASSERT(tensor->getImpl(),
// const Tensor& tensorWithValues = tensor->refCastFrom(cpyTensor, tensor->dataType(), "cpu"); "Tensor got no implementation, cannot fill it.");
AIDGE_ASSERT(NativeType<T>::type == tensor->dataType(), "Wrong data type");
// // Setting values
// for(std::size_t idx = 0; idx<tensorWithValues.size(); ++idx){ std::shared_ptr<Aidge::Tensor> cpyTensor;
// tensorWithValues.set<T>(idx, constantValue); // Create cpy only if tensor not on CPU
// } Aidge::Tensor& tensorWithValues =
tensor->refCastFrom(cpyTensor, tensor->dataType(), "cpu");
// // Copy values back to the original tensors (actual copy only if needed)
// tensor->copyCastFrom(tensorWithValues); // Setting values
for (std::size_t idx = 0; idx < tensorWithValues.size(); ++idx) {
tensorWithValues.set<T>(idx, constantValue);
// } }
// Copy values back to the original tensors (actual copy only if needed)
tensor->copyCastFrom(tensorWithValues);
}
template void Aidge::constantFiller<float>(std::shared_ptr<Aidge::Tensor>, float);
template void Aidge::constantFiller<double>(std::shared_ptr<Aidge::Tensor>, double);
src/filler/HeFiller.cpp 0 → 100644
+ 61
− 0
View file @ df4e4fc1
/********************************************************************************
* Copyright (c) 2023 CEA-List
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*
********************************************************************************/
#include <memory>
#include <random> // normal_distribution, uniform_real_distribution
#include "aidge/data/Tensor.hpp"
#include "aidge/filler/Filler.hpp"
template <typename T>
void Aidge::heFiller(std::shared_ptr<Aidge::Tensor> tensor,
Aidge::VarianceNorm varianceNorm, T meanNorm, T scaling) {
AIDGE_ASSERT(tensor->getImpl(),
"Tensor got no implementation, cannot fill it.");
AIDGE_ASSERT(NativeType<T>::type == tensor->dataType(), "Wrong data type");
unsigned int fanIn, fanOut = 0;
Aidge::calculateFanInFanOut(tensor, fanIn, fanOut);
const T n((varianceNorm == Aidge::VarianceNorm::FanIn) ? fanIn
: (varianceNorm == Aidge::VarianceNorm::Average)
? (fanIn + fanOut) / 2.0
: fanOut);
const T stdDev(std::sqrt(2.0 / n));
const T mean(varianceNorm == Aidge::VarianceNorm::FanIn ? meanNorm / fanIn
: (varianceNorm == Aidge::VarianceNorm::Average)
? meanNorm / ((fanIn + fanOut) / 2.0)
: meanNorm / fanOut);
std::random_device rd;
std::mt19937 gen(rd()); // Mersenne Twister pseudo-random number generator
std::normal_distribution<T> normalDist(mean, stdDev);
std::shared_ptr<Tensor> cpyTensor;
// Create cpy only if tensor not on CPU
Tensor& tensorWithValues =
tensor->refCastFrom(cpyTensor, tensor->dataType(), "cpu");
// Setting values
for (std::size_t idx = 0; idx < tensorWithValues.size(); ++idx) {
tensorWithValues.set<T>(idx, scaling*normalDist(gen));
}
// Copy values back to the original tensors (actual copy only if needed)
tensor->copyCastFrom(tensorWithValues);
}
template void Aidge::heFiller<float>(std::shared_ptr<Aidge::Tensor>,
Aidge::VarianceNorm, float, float);
template void Aidge::heFiller<double>(std::shared_ptr<Aidge::Tensor>,
Aidge::VarianceNorm, double, double);
src/filler/NormalFiller.cpp 0 → 100644
+ 45
− 0
View file @ df4e4fc1
/********************************************************************************
* Copyright (c) 2023 CEA-List
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*
********************************************************************************/
#include <memory>
#include <random> // normal_distribution, uniform_real_distribution
#include "aidge/data/Tensor.hpp"
#include "aidge/filler/Filler.hpp"
template <typename T>
void Aidge::normalFiller(std::shared_ptr<Aidge::Tensor> tensor, double mean,
double stdDev) {
AIDGE_ASSERT(tensor->getImpl(),
"Tensor got no implementation, cannot fill it.");
AIDGE_ASSERT(NativeType<T>::type == tensor->dataType(), "Wrong data type");
std::random_device rd;
std::mt19937 gen(rd()); // Mersenne Twister pseudo-random number generator
std::normal_distribution<T> normalDist(mean, stdDev);
std::shared_ptr<Tensor> cpyTensor;
// Create cpy only if tensor not on CPU
Tensor& tensorWithValues =
tensor->refCastFrom(cpyTensor, tensor->dataType(), "cpu");
// Setting values
for (std::size_t idx = 0; idx < tensorWithValues.size(); ++idx) {
tensorWithValues.set<T>(idx, normalDist(gen));
}
// Copy values back to the original tensors (actual copy only if needed)
tensor->copyCastFrom(tensorWithValues);
}
template void Aidge::normalFiller<float>(std::shared_ptr<Aidge::Tensor>, double,
double);
template void Aidge::normalFiller<double>(std::shared_ptr<Aidge::Tensor>,
double, double);
src/filler/UniformFiller.cpp 0 → 100644
+ 44
− 0
View file @ df4e4fc1
/********************************************************************************
* Copyright (c) 2023 CEA-List
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*
********************************************************************************/
#include <memory>
#include <random> // normal_distribution, uniform_real_distribution
#include "aidge/data/Tensor.hpp"
#include "aidge/filler/Filler.hpp"
template <typename T>
void Aidge::uniformFiller(std::shared_ptr<Aidge::Tensor> tensor, T min, T max) {
AIDGE_ASSERT(tensor->getImpl(),
"Tensor got no implementation, cannot fill it.");
AIDGE_ASSERT(NativeType<T>::type == tensor->dataType(), "Wrong data type");
std::random_device rd;
std::mt19937 gen(rd()); // Mersenne Twister pseudo-random number generator
std::uniform_real_distribution<T> uniformDist(min, max);
std::shared_ptr<Aidge::Tensor> cpyTensor;
// Create cpy only if tensor not on CPU
Aidge::Tensor& tensorWithValues =
tensor->refCastFrom(cpyTensor, tensor->dataType(), "cpu");
// Setting values
for (std::size_t idx = 0; idx < tensorWithValues.size(); ++idx) {
tensorWithValues.set<T>(idx, uniformDist(gen));
}
// Copy values back to the original tensors (actual copy only if needed)
tensor->copyCastFrom(tensorWithValues);
}
template void Aidge::uniformFiller<float>(std::shared_ptr<Aidge::Tensor>, float,
float);
template void Aidge::uniformFiller<double>(std::shared_ptr<Aidge::Tensor>,
double, double);
src/filler/XavierFiller.cpp 0 → 100644
+ 94
− 0
View file @ df4e4fc1
/********************************************************************************
* Copyright (c) 2023 CEA-List
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*
********************************************************************************/
#include <memory>
#include <random> // normal_distribution, uniform_real_distribution
#include "aidge/data/Tensor.hpp"
#include "aidge/filler/Filler.hpp"
template <typename T>
void Aidge::xavierUniformFiller(std::shared_ptr<Aidge::Tensor> tensor, T scaling,
Aidge::VarianceNorm varianceNorm) {
AIDGE_ASSERT(tensor->getImpl(),
"Tensor got no implementation, cannot fill it.");
AIDGE_ASSERT(NativeType<T>::type == tensor->dataType(), "Wrong data type");
unsigned int fanIn, fanOut = 0;
Aidge::calculateFanInFanOut(tensor, fanIn, fanOut);
const T n((varianceNorm == Aidge::VarianceNorm::FanIn) ? fanIn
: (varianceNorm == Aidge::VarianceNorm::Average)
? (fanIn + fanOut) / 2.0
: fanOut);
const T scale(std::sqrt(3.0 / n));
std::random_device rd;
std::mt19937 gen(rd()); // Mersenne Twister pseudo-random number generator
std::uniform_real_distribution<T> uniformDist(-scale, scale);
std::shared_ptr<Aidge::Tensor> cpyTensor;
// Create cpy only if tensor not on CPU
Aidge::Tensor& tensorWithValues =
tensor->refCastFrom(cpyTensor, tensor->dataType(), "cpu");
// Setting values
for (std::size_t idx = 0; idx < tensorWithValues.size(); ++idx) {
T value = scaling * uniformDist(gen);
tensorWithValues.set<T>(idx, value);
}
// Copy values back to the original tensors (actual copy only if needed)
tensor->copyCastFrom(tensorWithValues);
}
template <typename T>
void Aidge::xavierNormalFiller(std::shared_ptr<Aidge::Tensor> tensor, T scaling,
Aidge::VarianceNorm varianceNorm) {
AIDGE_ASSERT(tensor->getImpl(),
"Tensor got no implementation, cannot fill it.");
AIDGE_ASSERT(NativeType<T>::type == tensor->dataType(), "Wrong data type");
unsigned int fanIn, fanOut = 0;
Aidge::calculateFanInFanOut(tensor, fanIn, fanOut);
const T n((varianceNorm == Aidge::VarianceNorm::FanIn) ? fanIn
: (varianceNorm == Aidge::VarianceNorm::Average)
? (fanIn + fanOut) / 2.0
: fanOut);
const double stdDev(std::sqrt(1.0 / n));
std::random_device rd;
std::mt19937 gen(rd()); // Mersenne Twister pseudo-random number generator
std::normal_distribution<T> normalDist(0.0, stdDev);
std::shared_ptr<Aidge::Tensor> cpyTensor;
// Create cpy only if tensor not on CPU
Aidge::Tensor& tensorWithValues =
tensor->refCastFrom(cpyTensor, tensor->dataType(), "cpu");
// Setting values
for (std::size_t idx = 0; idx < tensorWithValues.size(); ++idx) {
tensorWithValues.set<T>(idx, scaling*normalDist(gen));
}
// Copy values back to the original tensors (actual copy only if needed)
tensor->copyCastFrom(tensorWithValues);
}
template void Aidge::xavierUniformFiller<float>(std::shared_ptr<Aidge::Tensor>,
float, Aidge::VarianceNorm);
template void Aidge::xavierUniformFiller<double>(std::shared_ptr<Aidge::Tensor>,
double, Aidge::VarianceNorm);
template void Aidge::xavierNormalFiller<float>(std::shared_ptr<Aidge::Tensor>,
float, Aidge::VarianceNorm);
template void Aidge::xavierNormalFiller<double>(std::shared_ptr<Aidge::Tensor>,
double, Aidge::VarianceNorm);
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

Copyright © Eclipse Foundation, Inc. All Rights Reserved.     Privacy Policy | Terms of Use | Copyright Agent