tensor.h

Go to the documentation of this file.

 
#ifndef NNLIB_TENSOR_H
#define NNLIB_TENSOR_H
 
#include "allocation.h"
#include "cache.h"
#include "session.cuh"
#include <cstdlib>
#include <iostream>
#include <memory>
#include <utility>
#include <vector>
 
class BackwardFunction; // forward declaration to solve a circular dependency
 
 
class Tensor {
 
public:
    std::vector<size_t> shape;
 
    size_t size;
 
    DataLocation location;
 
    float* data;
 
    Session session;
 
    bool requiresGrad;
    std::shared_ptr<BackwardFunction> gradFunction;
    std::shared_ptr<Tensor> grad;
 
    Tensor();
 
    Tensor(const Tensor& other);
 
    explicit Tensor(std::vector<size_t> shape);
 
    Tensor(std::vector<size_t> shape, DataLocation location);
 
    template<typename... Args>
    explicit Tensor(Args... args) : Tensor(std::vector<size_t>({static_cast<size_t>(args)...})) {
    }
 
    Tensor& operator=(const Tensor& other);
 
    [[nodiscard]] std::shared_ptr<Tensor> copy() const;
 
    void move(DataLocation target);
 
    void useGrad();
    void backward();
 
    static Tensor construct1d(const std::vector<float>& data);
 
    static Tensor construct2d(const std::vector<std::vector<float>>& data);
 
    template<typename... Args>
    float& operator()(Args... args) {
        std::vector<size_t> index = std::vector<size_t>({static_cast<size_t>(args)...});
        // Make sure the indexes are within acceptable range and throw SizeMismatchException if not.
        verifyIndex(index);
        // Recursively figure out the index in the flattened array (the effective index)
        size_t effectiveIndex = findEffectiveAddress(index, shape.size() - 1);
        return data[effectiveIndex];
    }
 
    ~Tensor();
 
private:
    void computeSize();
 
    [[nodiscard]] size_t findEffectiveAddress(const std::vector<size_t>& index, size_t depth) const;
 
    void verifyIndex(const std::vector<size_t>& index) const;
};
 
typedef std::shared_ptr<Tensor> sTensor;
 
std::ostream& operator<<(std::ostream& stream, const Tensor& tensor);
 
sTensor sum(const sTensor& a);
 
void fill(float value, sTensor& tensor);
void fill(const sTensor& value, sTensor& tensor);
 
sTensor add(const sTensor& a, const sTensor& b);
 
sTensor subtract(const sTensor& a, const sTensor& b);
 
sTensor hadamard(const sTensor& a, const sTensor& b);
 
sTensor divide(const sTensor& a, const sTensor& b);
 
sTensor log(const sTensor& a);
 
sTensor multiply(const sTensor& a, float constant);
 
sTensor multiply(const sTensor& a, const sTensor& b);
 
sTensor transpose(const sTensor& a);
 
sTensor relu(const sTensor& a);
 
sTensor sigmoid(const sTensor& a);
 
namespace no_grad {
    sTensor sum(const sTensor& a);
 
    sTensor add(const sTensor& a, const sTensor& b);
 
    sTensor subtract(const sTensor& a, const sTensor& b);
 
    sTensor hadamard(const sTensor& a, const sTensor& b);
 
    sTensor divide(const sTensor& a, const sTensor& b);
 
    sTensor log(const sTensor& a);
 
    sTensor multiply(const sTensor& a, float constant);
 
    sTensor multiply(const sTensor& a, const sTensor& b);
 
    sTensor transpose(const sTensor& a);
 
    sTensor relu(const sTensor& a);
 
    sTensor sigmoid(const sTensor& a);
} // namespace no_grad
 
#endif //NNLIB_TENSOR_H