text stringlengths 1 24.5M |
|---|
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "RefBaseWorkload.hpp"
#include <armnn/backends/WorkloadData.hpp>
namespace armnn
{
class RefStackWorkload : public RefBaseWorkload<StackQueueDescriptor>
{
public:
explicit RefSta... |
//
// Copyright © 2018-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefStridedSliceWorkload.hpp"
#include "RefWorkloadUtils.hpp"
#include "StridedSlice.hpp"
namespace armnn
{
RefStridedSliceWorkload::RefStridedSliceWorkload(const StridedSliceQueueDescriptor& descr... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "RefBaseWorkload.hpp"
namespace armnn
{
class RefStridedSliceWorkload : public RefBaseWorkload<StridedSliceQueueDescriptor>
{
public:
RefStridedSliceWorkload(const StridedSliceQu... |
//
// Copyright © 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefTileWorkload.hpp"
#include "RefWorkloadUtils.hpp"
#include "Tile.hpp"
#include "Profiling.hpp"
namespace armnn
{
RefTileWorkload::RefTileWorkload(const TileQueueDescriptor& descriptor, cons... |
//
// Copyright © 2020-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "RefBaseWorkload.hpp"
#include <armnn/backends/WorkloadData.hpp>
#include "Tile.hpp"
namespace armnn
{
class RefTileWorkload : public RefBaseWorkload<TileQueueDescriptor>
{
... |
//
// Copyright © 2019,2021-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefTransposeConvolution2dWorkload.hpp"
#include "RefWorkloadUtils.hpp"
#include "TransposeConvolution2d.hpp"
#include <Profiling.hpp>
namespace armnn
{
RefTransposeConvolution2dWorkload::Re... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Decoders.hpp"
#include "Encoders.hpp"
#include <armnn/backends/TensorHandle.hpp>
#include "RefBaseWorkload.hpp"
namespace armnn
{
class RefTransposeConvolution2dWorkload : public R... |
//
// Copyright © 2020-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefTransposeWorkload.hpp"
#include "RefWorkloadUtils.hpp"
#include <armnnUtils/Transpose.hpp>
#include <ResolveType.hpp>
namespace armnn
{
template <armnn::DataType DataType>
void RefTransposeWo... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "RefBaseWorkload.hpp"
#include <armnn/TypesUtils.hpp>
namespace armnn
{
template <armnn::DataType DataType>
class RefTransposeWorkload : public TypedWorkload<TransposeQueueDescripto... |
//
// Copyright © 2021-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefUnidirectionalSequenceLstmWorkload.hpp"
#include "Activation.hpp"
#include "Encoders.hpp"
#include "Decoders.hpp"
#include "Lstm.hpp"
#include "LstmUtils.hpp"
#include "RefWorkloadUtils.hpp"
#in... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/TypesUtils.hpp>
#include "RefBaseWorkload.hpp"
#include <armnn/backends/WorkloadData.hpp>
#include "Encoders.hpp"
#include "Decoders.hpp"
namespace armnn
{
class RefUnidirec... |
//
// Copyright © 2017-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "RefActivationWorkload.hpp"
#include "RefArgMinMaxWorkload.hpp"
#include "RefBatchMatMulWorkload.hpp"
#include "RefBatchNormalizationWorkload.hpp"
#include "RefBatchToSpaceNdWorkload.hp... |
//
// Copyright © 2017-2023 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/TensorHandle.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/Types.hpp>
#include <armnn/utility/PolymorphicDowncast.hpp>
#include <reference/RefTensorHandle.hpp>
#include <BFloat16.h... |
//
// Copyright © 2017, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Resize.hpp"
#include "TensorBufferArrayView.hpp"
#include <armnn/utility/NumericCast.hpp>
#include <armnn/Utils.hpp>
#include <cmath>
#include <algorithm>
using namespace armnnUtils;
namespace
{
inline float ... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BaseIterator.hpp"
#include <armnn/Tensor.hpp>
#include <armnnUtils/DataLayoutIndexed.hpp>
namespace armnn
{
void Resize(Decoder<float>& in,
const TensorInfo& inputI... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ReverseV2Impl.hpp"
#include <armnn/backends/WorkloadData.hpp>
#include <armnn/Logging.hpp>
#include <armnnUtils/Permute.hpp>
namespace armnn
{
// Get multi-dimensional index for input tensor
std::vect... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Encoders.hpp"
#include "Decoders.hpp"
#include <armnn/backends/WorkloadData.hpp>
namespace armnn
{
void ReverseV2(const TensorInfo& inputInfo,
const TensorInfo& axisInfo,
... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <iostream>
namespace armnn
{
template<typename T>
struct rsqrt
{
typedef T result_type;
typedef T argument_type;
T
operator () (const T& inputData) const
{
... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ScatterNd.hpp"
#include "Encoders.hpp"
#include <armnn/backends/WorkloadData.hpp>
#include <armnn/Logging.hpp>
#include <fmt/format.h>
#include <numeric>
namespace armnn
{
float ScatterOperation(Scat... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Tensor.hpp>
#include "Encoders.hpp"
#include "Decoders.hpp"
#include "armnn/Descriptors.hpp"
namespace armnn
{
// ScatterNd with input tensor
void ScatterNd(const TensorInfo& inputIn... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <iostream>
namespace armnn
{
template<typename T>
struct sin
{
typedef T result_type;
typedef T argument_type;
T
operator () (const T& inputData) const... |
//
// Copyright © 2019,2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Slice.hpp"
#include <armnn/utility/Assert.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
namespace armnn
{
void Slice(const TensorInfo& inputInfo,
const SliceDescriptor& descriptor,
const vo... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Descriptors.hpp>
#include "BaseIterator.hpp"
namespace armnn
{
void Slice(const TensorInfo& inputInfo,
const SliceDescriptor& descriptor,
const void* inputData,
vo... |
//
// Copyright © 2017, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Softmax.hpp"
#include <armnnUtils/TensorUtils.hpp>
#include <cmath>
#include <vector>
namespace armnn
{
/// Computes the softmax function on some inputs, into outputs, with a shape given by tensorInfo.
void Sof... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BaseIterator.hpp"
#include <armnn/Tensor.hpp>
namespace armnn
{
/// Computes the softmax function on some inputs, into outputs, with a shape given by tensorInfo.
void Softmax(Decoder<float>& in, Encoder<f... |
//
// Copyright © 2017-2019,2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "SpaceToBatchNd.hpp"
#include <armnnUtils/DataLayoutIndexed.hpp>
using namespace armnnUtils;
namespace armnn
{
unsigned int GetOffset(const TensorShape& shape,
unsigne... |
//
// Copyright © 2017-2019,2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BaseIterator.hpp"
#include "Decoders.hpp"
#include "Encoders.hpp"
#include <armnn/Descriptors.hpp>
namespace armnn
{
void SpaceToBatchNd(const TensorInfo& inputInfo,
... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "SpaceToDepth.hpp"
#include <armnnUtils/DataLayoutIndexed.hpp>
using namespace armnnUtils;
namespace {
unsigned int GetOffset(const armnn::TensorShape& shape,
unsigned int c,
unsigned int h,
... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BaseIterator.hpp"
#include "Decoders.hpp"
#include "Encoders.hpp"
#include <armnn/Descriptors.hpp>
#include <armnn/Tensor.hpp>
namespace armnn
{
void SpaceToDepth(const TensorInfo& inputInfo,
... |
//
// Copyright © 2017, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RefWorkloadUtils.hpp"
#include <armnn/backends/WorkloadData.hpp>
#include <armnn/Tensor.hpp>
#include "Splitter.hpp"
#include <cmath>
#include <limits>
#include "Decoders.hpp"
#include "Encoders.hpp"
namespace a... |
//
// Copyright © 2017, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "RefWorkloadUtils.hpp"
#include <armnn/backends/WorkloadData.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/utility/Assert.hpp>
namespace armnn
{
template <typename DataType>
void Splitter(const Sp... |
//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <iostream>
namespace armnn
{
template<typename T>
struct sqrt
{
typedef T result_type;
typedef T argument_type;
T
operator () (const T& inputData) const
{
... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cmath>
namespace armnn
{
template<typename T>
struct squaredDifference
{
typedef T result_type;
typedef T first_argument_type;
T
operator()(const T& input1, const T& inpu... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Stack.hpp"
#include "RefWorkloadUtils.hpp"
namespace armnn
{
void Stack(const StackQueueDescriptor& data,
std::vector<std::unique_ptr<Decoder<float>>>& inputs,
Encoder<float>& output,
c... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Encoders.hpp"
#include "Decoders.hpp"
#include <armnn/backends/WorkloadData.hpp>
namespace armnn
{
void Stack (const StackQueueDescriptor& data,
std::vector<std::unique_ptr<... |
//
// Copyright © 2017, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "StridedSlice.hpp"
#include <armnn/utility/NumericCast.hpp>
#include <cstring>
namespace armnn
{
namespace
{
void PadParams(StridedSliceDescriptor& p, unsigned int dimCount)
{
ARMNN_THROW_INVALIDARG_MSG_IF_... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Descriptors.hpp>
#include <armnn/Tensor.hpp>
namespace armnn
{
void StridedSlice(const TensorInfo& inputInfo,
const StridedSliceDescriptor& params,
const void* in... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "StringMapping.hpp"
namespace armnn
{
const StringMapping& StringMapping::Instance()
{
static StringMapping instance;
return instance;
}
} // armnn
|
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace armnn
{
///
/// StringMapping is helper class to be able to use strings as template
/// parameters, so this allows simplifying code which only differs in
/// a string, such as a debug string literal.
///
s... |
//
// Copyright © 2017, 2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Tensor.hpp>
#include <armnnUtils/DataLayoutIndexed.hpp>
namespace armnn
{
// Utility class providing access to raw tensor memory based on indices along each dimension.
template <typename Data... |
//
// Copyright © 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Tile.hpp"
#include "Encoders.hpp"
#include <numeric>
#include <armnn/backends/WorkloadData.hpp>
#include <armnn/Logging.hpp>
namespace armnn
{
// Converts a flatten index into a multi-dimensional ... |
//
// Copyright © 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/Tensor.hpp>
#include "Encoders.hpp"
#include "Decoders.hpp"
#include "armnn/Descriptors.hpp"
namespace armnn
{
template<typename I, typename O>
void Tile(const TileDescriptor& ... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TransposeConvolution2d.hpp"
#include <armnnUtils/DataLayoutIndexed.hpp>
namespace armnn
{
using namespace armnnUtils;
void TransposeConvolution2dImpl(const TransposeConvolution2dDescriptor& descriptor,
... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Decoders.hpp"
#include "Encoders.hpp"
#include <armnn/Descriptors.hpp>
#include <armnn/Tensor.hpp>
namespace armnn
{
void TransposeConvolution2dImpl(const TransposeConvolution2dDescriptor& descriptor,
... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <tosa_serialization_handler.h>
using namespace armnn;
using namespace tosa;
// List of Layer Support Rules common to TOSA backends only, for use with CheckSupportRule()
struct TosaO... |
//
// Copyright © 2022-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TosaMappings.hpp"
#include "tosaCommon/operatorMappings/PReluOperator.hpp"
#include "tosaCommon/operatorMappings/BatchToSpaceOperator.hpp"
#include "tosaCommon/operatorMappings/SpaceToBatchOperator.... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <Layer.hpp>
#include <tosa_serialization_handler.h>
#include "operatorMappings/TosaCommonOperators.hpp"
using namespace armnn;
using namespace tosa;
// Populates a tosa::TosaSerialization... |
//
// Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Pooling2DOperator.hpp"
TosaSerializationBasicBlock* ConvertAvgPool2DIgnoreValueToTosaOperator(const Layer* layer,
const std::v... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
#include <Layer.hpp>
#include <tosa_serialization_handler.h>
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertAvgPool2DIgnoreValue... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "BatchMatMulOperator.hpp"
#include "TosaRescaleOperatorUtils.hpp"
// This function is paraphras... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertBatchMatMulToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "BatchToSpaceOperator.hpp"
TosaSerializationBasicBlock* ConvertBatchToSpaceToTosaOperator(co... |
//
// Copyright © 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertBatchToSpaceToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ConcatOperator.hpp"
TosaSerializationBasicBlock* ConvertConcatToTosaOperator(const Layer* layer,
const std::vector<const TensorInfo*>& input... |
//
// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertConcatToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2022, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ConstantOperator.hpp"
#include <layers/ConstantLayer.hpp>
TosaSerializationBasicBlock* ConvertConstantToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertConstantToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Conv2dOperator.hpp"
#include "TosaRescaleOperatorUtils.hpp"
#include <ResolveType.hpp>
TosaSerializationBasicBlock* ConvertConv2dToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertConv2dToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "Conv3dOperator.hpp"
#include "TosaRescaleOperatorUtils.hpp"
#include <ResolveType.hpp>
// T... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertConv3dToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "DepthToSpaceOperator.hpp"
// This function is paraphrased from:
// tensorflow/compiler/mlir... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertDepthToSpaceToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "DepthwiseConv2dOperator.hpp"
#include "TosaRescaleOperatorUtils.hpp"
#include <ResolveType.hpp>
TosaSerializationBasicBlock* ConvertDepthwiseConv2dToTosaOperator(
const Layer* layer,
const ... |
//
// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertDepthwiseConv2dToTosaOperator(
const Layer* layer,
const std::vector<c... |
//
// Copyright © 2024-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "DequantizeOperator.hpp"
TosaSerializationBasicBlock* ConvertDequantizeToTosaOperator(
const Layer* layer,
const std::vector<const TensorInfo*>& inputs,
const std::vector<const TensorInf... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertDequantizeToTosaOperator(
const Layer* layer,
const std::vector<const Tenso... |
//
// Copyright © 2022-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ElementwiseBinaryOperator.hpp"
#include "TosaRescaleOperatorUtils.hpp"
TosaSerializationBasicBlock* ConvertElementwiseBinaryToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2022-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertElementwiseBinaryToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "ExpOperator.hpp"
#include "TosaTableUtils.hpp"
TosaSerializationBasicBlock* ConvertExpOpera... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertExpOperator(const Layer* layer,
con... |
//
// Copyright © 2024 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include <numeric>
#include "FullyConnectedOperator.hpp"
#include "TosaRescaleOperatorUtils.hpp"
/... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertFullyConnectedToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "StackOperator.hpp"
#include <numeric>
// This function is paraphrased from:
// tensorflow/... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertGatherToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "GeluOperator.hpp"
#include "TosaTableUtils.hpp"
#include <layers/ActivationLayer.hpp>
// T... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <Layer.hpp>
#include <tosa_serialization_handler.h>
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertGeluToTosaOperator(c... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "HardSwishOperator.hpp"
#include <gemmlowp/fixedpoint.h>
// This function is paraphrased fr... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertHardSwishToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "LeakyReluOperator.hpp"
#include "TosaRescaleOperatorUtils.hpp"
#include <layers/ActivationL... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <Layer.hpp>
#include <tosa_serialization_handler.h>
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertLeakyReluToTosaOpera... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "LogOperator.hpp"
#include "TosaTableUtils.hpp"
TosaSerializationBasicBlock* ConvertLogOpera... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertLogOperator(const Layer* layer,
con... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "PadOperator.hpp"
#include <armnnUtils/QuantizeHelper.hpp>
TosaSerializationBasicBlock* ConvertPadToTosaOperator(const Layer* layer,
const std::vecto... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertPadToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Pooling2DOperator.hpp"
TosaSerializationBasicBlock* ConvertPooling2DToTosaOperator(const Layer* layer,
const std::vector<const TensorInfo... |
//
// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertPooling2DToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "PReluOperator.hpp"
#include "TosaRescaleOperatorUtils.hpp"
#include <layers/ActivationLayer... |
//
// Copyright © 2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <Layer.hpp>
#include <tosa_serialization_handler.h>
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertPReluToTosaOperator(... |
//
// Copyright © 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "QuantizeOperator.hpp"
#include "TosaRescaleOperatorUtils.hpp"
#include <fmt/format.h>
/... |
//
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertQuantizeToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2024-2025 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "ReduceOperator.hpp"
#include <armnn/TypesUtils.hpp>
#include "TosaRescaleOperatorUtils.hp... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
TosaSerializationBasicBlock* ConvertReduceToTosaOperator(const Layer* layer,
const std::vector<const TensorI... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
//
// Copyright © 2020 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include "LeakyReluOperator.hpp"
#include "TosaRescaleOperatorUtils.hpp"
#include <layers/ActivationL... |
//
// Copyright © 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <Layer.hpp>
#include <tosa_serialization_handler.h>
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertReluToTosaOperator(c... |
//
// Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ReshapeOperator.hpp"
TosaSerializationBasicBlock* ConvertReshapeToTosaOperator(const Layer* layer,
const std::vector<const TensorInfo*>& in... |
//
// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertReshapeToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
// Copyright © 2020, 2023 The TensorFlow Authors. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//
#include <numeric>
#include "ResizeOperator.hpp"
#include "TosaRescaleOperatorUtils.hpp"
// T... |
//
// Copyright © 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TosaOperatorUtils.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* ConvertResizeToTosaOperator(const Layer* layer,
... |
//
// Copyright © 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "RsqrtOperator.hpp"
#include "TosaTableUtils.hpp"
TosaSerializationBasicBlock* ConvertRsqrtOperator(const Layer* layer,
const std::vector<const Tens... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.