mtlearn 0.1.2__tar.gz → 0.1.4__tar.gz

mtlearn-0.1.4/.gitignore

@@ -0,0 +1,12 @@
+build/
+dist/
+__pycache__/
+*.egg-info/
+.pytest_cache/
+.scannerwork/
+.idea/
+.vscode/
+dat/.DS_Store
+/notebooks/.ipynb_checkpoints
+python/mtlearn/.DS_Store
+notebooks/.ipynb_checkpoints/AreaOpening-checkpoint.ipynb

{mtlearn-0.1.2 → mtlearn-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mtlearn
-Version: 0.1.2
+Version: 0.1.4
 Summary: Morphological tree learning utilities built on top of mmcfilters
 Author-Email: Wonder Alexandre Luz Alves <worderalexandre@gmail.com>
 Classifier: Programming Language :: Python
@@ -10,7 +10,7 @@ Classifier: Operating System :: MacOS
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
 Requires-Python: >=3.9
-Requires-Dist: mmcfilters>=0.1.20
+Requires-Dist: mmcfilters>=0.1.23
 Provides-Extra: torch
 Requires-Dist: torch>=2.0; extra == "torch"
 Description-Content-Type: text/markdown
@@ -58,9 +58,10 @@ cmake --build build
 Para rodar o teste com interpretador embutido:
 
 ```bash
-cmake -S . -B build -DMTLEARN_BUILD_TESTS=ON -DMTLEARN_ENABLE_EMBED=ON \
-      -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") \
-      -DPYTHON_LIBRARY_DIR=$(python3 -c "import sysconfig; print(sysconfig.get_config_var('LIBDIR'))")
+#cmake -S . -B build -DMTLEARN_BUILD_TESTS=ON -DMTLEARN_ENABLE_EMBED=ON \
+#      -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") \
+#      -DPYTHON_LIBRARY_DIR=$(python3 -c "import sysconfig; print(sysconfig.get_config_var('LIBDIR'))")
+cmake -S . -B build -DCMAKE_INSTALL_PREFIX=$(python -c "import site; print(site.getsitepackages()[0])")
 cmake --build build
 ctest --test-dir build -R mtl_interpreter_test --output-on-failure
 ```

{mtlearn-0.1.2 → mtlearn-0.1.4}/README.md

@@ -41,9 +41,10 @@ cmake --build build
 Para rodar o teste com interpretador embutido:
 
 ```bash
-cmake -S . -B build -DMTLEARN_BUILD_TESTS=ON -DMTLEARN_ENABLE_EMBED=ON \
-      -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") \
-      -DPYTHON_LIBRARY_DIR=$(python3 -c "import sysconfig; print(sysconfig.get_config_var('LIBDIR'))")
+#cmake -S . -B build -DMTLEARN_BUILD_TESTS=ON -DMTLEARN_ENABLE_EMBED=ON \
+#      -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") \
+#      -DPYTHON_LIBRARY_DIR=$(python3 -c "import sysconfig; print(sysconfig.get_config_var('LIBDIR'))")
+cmake -S . -B build -DCMAKE_INSTALL_PREFIX=$(python -c "import site; print(site.getsitepackages()[0])")
 cmake --build build
 ctest --test-dir build -R mtl_interpreter_test --output-on-failure
 ```

mtlearn-0.1.4/bindings/.ipynb_checkpoints/ConnectedFilterByJacobian-checkpoint.hpp

@@ -0,0 +1,108 @@
+#pragma once
+
+
+#include <mmcfilters/attributes/AttributeComputedIncrementally.hpp>
+#include <mmcfilters/trees/NodeMT.hpp>
+#include <mmcfilters/trees/MorphologicalTree.hpp>
+#include <mmcfilters/utils/Common.hpp>
+
+#include "MorphologicalTreePybind.hpp"
+#include "PybindTorchUtils.hpp"
+
+#include <memory>
+#include <vector>
+#include <tuple>
+
+#include <pybind11/pybind11.h>
+#include <torch/extension.h>
+#include <ATen/ops/_sparse_mm.h>
+
+
+
+namespace mtlearn {
+
+namespace py = pybind11;
+
+using mmcfilters::AttributeComputedIncrementally;
+using mmcfilters::InvalidNode;
+using mmcfilters::MorphologicalTreePybindPtr;
+using mmcfilters::NodeId;
+
+class ConnectedFilterByJacobian {
+public:
+
+    
+    static torch::Tensor filtering(
+                                            const torch::Tensor& pixel_to_node,         // [N_pixels]
+                                            const torch::Tensor& residues,             // [N_nodes]
+                                            const torch::Tensor& sigmoid              // [N_nodes]
+                                        ) {
+
+        auto node_filter = residues * sigmoid;     // [N_nodes]
+        return node_filter.index_select(0, pixel_to_node);  // [N_pixels]
+    }
+
+
+    static py::tuple gradients(const torch::Tensor& jacobian,  
+                                                    const torch::Tensor& residues, 
+                                                    const torch::Tensor& attributes, 
+                                                    const torch::Tensor& sigmoid,  
+                                                    const torch::Tensor& grad_output) { 
+
+        // 1. Gradiente da sigmoide
+        auto d_sigmoid = sigmoid * (1 - sigmoid); // Element-wise, Shape: [N_nodes]
+
+        // 2. Gradientes para os nós
+        auto grad_filter = residues * d_sigmoid; // Shape: [N_nodes]
+        auto grad_bias_nodes = grad_filter.unsqueeze(1); // Shape: [N_nodes, 1]
+        auto grad_weight_nodes = grad_bias_nodes * attributes; // Shape: [N_nodes, D_attributes]
+
+        // 3. Projeção com Jacobiana
+        auto grad_bias_pixels = at::_sparse_mm(jacobian.t(), grad_bias_nodes); // [N_pixels, 1]
+        auto grad_weight_pixels = at::_sparse_mm(jacobian.t(), grad_weight_nodes); // [N_pixels, D_attributes]
+
+        // 4. Gradientes finais
+        auto grad_bias = grad_output.t().matmul(grad_bias_pixels); // Scalar [1]
+        auto grad_weight = grad_output.t().matmul(grad_weight_pixels).reshape({-1, 1});  // Shape: [D_attributes, 1]; // [1, D_attributes]
+
+        return py::make_tuple(grad_bias, grad_weight); 
+    }
+
+
+
+
+
+
+    static py::tuple computeGradientsEfficient(
+                                                const torch::Tensor& pixel_to_node,            // [N_pixels]                                        
+                                                const torch::Tensor& residues,                 // [N_nodes]
+                                                const torch::Tensor& sigmoid,                  // [N_nodes]                                        
+                                                const torch::Tensor& attributes,               // [N_nodes, D]
+                                                const torch::Tensor& grad_output               // [N_pixels]
+                                                ) {
+        // 1. Derivada da sigmoide
+        auto d_sigmoid = sigmoid * (1 - sigmoid);      // [N_nodes]
+    
+        // 2. Gradiente do filtro por nó
+        auto node_filter_grad = residues * d_sigmoid;  // [N_nodes]
+    
+        // 3. Gradiente da saída dos pixels: para cada pixel, obter o gradiente do nó correspondente
+        auto node_grad_per_pixel = node_filter_grad.index_select(0, pixel_to_node);  // [N_pixels]
+    
+        // 4. Gradientes por pixel
+        auto grad_bias_pixels = node_grad_per_pixel;  // [N_pixels]
+        auto grad_weight_pixels = grad_bias_pixels.unsqueeze(1) * attributes.index_select(0, pixel_to_node);  // [N_pixels, D]
+    
+        // 5. Projeção final (produto com grad_output)
+        auto grad_bias = (grad_output * grad_bias_pixels).sum();                       // Escalar
+        //auto grad_weight = (grad_output.unsqueeze(1) * grad_weight_pixels).sum(0);     // [D]
+        auto grad_weight = (grad_output.unsqueeze(1) * grad_weight_pixels).sum(0).unsqueeze(1); // [D, 1]
+
+        return py::make_tuple(grad_weight, grad_bias.unsqueeze(0).unsqueeze(0));
+    }
+        
+
+
+};
+
+} // namespace mtlearn

mtlearn-0.1.4/bindings/.ipynb_checkpoints/ConnectedFilterByMorphologicalTree-checkpoint.hpp

@@ -0,0 +1,258 @@
+#pragma once
+
+
+#include <mmcfilters/attributes/AttributeComputedIncrementally.hpp>
+#include <mmcfilters/trees/NodeMT.hpp>
+#include <mmcfilters/trees/MorphologicalTree.hpp>
+#include <mmcfilters/utils/Common.hpp>
+
+#include "MorphologicalTreePybind.hpp"
+#include "PybindTorchUtils.hpp"
+
+#include <memory>
+#include <vector>
+#include <tuple>
+
+#include <pybind11/pybind11.h>
+#include <torch/extension.h>
+
+
+
+namespace mtlearn {
+
+namespace py = pybind11;
+
+using mmcfilters::AttributeComputedIncrementally;
+using mmcfilters::InvalidNode;
+using mmcfilters::MorphologicalTreePybindPtr;
+using mmcfilters::MorphologicalTreePybind;
+using mmcfilters::NodeId;
+
+class ConnectedFilterByMorphologicalTree {
+public:
+
+    
+    static torch::Tensor filtering(MorphologicalTreePybindPtr tree, torch::Tensor sigmoid) {
+        int numRows = tree->getNumRowsOfImage();
+        int numCols = tree->getNumColsOfImage();
+        int n = numRows * numCols;
+        float* sigmoid_ptr = sigmoid.data_ptr<float>();
+        
+        std::unique_ptr<float[]> mapLevel(new float[tree->getNumNodes()]);
+
+        // The root is always kept
+        NodeId rootId = tree->getRootById();
+        mapLevel[rootId] = tree->getLevelById(rootId);
+        for (NodeId nodeId : tree->getNodeIds()) {
+            if (tree->getParentById(nodeId) != InvalidNode) {
+                float residue = static_cast<float>(tree->getResidueById(nodeId));
+                mapLevel[nodeId] = mapLevel[tree->getParentById(nodeId)] + (residue * sigmoid_ptr[nodeId]);
+            }
+        }
+
+        auto out = torch::empty({numRows, numCols}, torch::kFloat32);
+        float* imgOutput = out.data_ptr<float>();
+        for (NodeId nodeId : tree->getNodeIds()) {
+            for (int pixel : tree->getCNPsById(nodeId)) {
+                imgOutput[pixel] = mapLevel[nodeId];
+            }
+        }
+
+        return out;
+    }
+
+
+    static std::tuple<torch::Tensor, torch::Tensor> gradients(MorphologicalTreePybindPtr treePtr, torch::Tensor attrs, torch::Tensor sigmoid, torch::Tensor gradientOfLoss) {
+        float* attributes = attrs.data_ptr<float>();
+        float* sigmoid_ptr = sigmoid.data_ptr<float>();
+        MorphologicalTreePybind* tree = treePtr.get();
+        int rows = attrs.size(0); // numNodes
+        int cols = attrs.size(1); // numFeatures
+        torch::Tensor gradFilterWeights = torch::empty({rows * cols}, torch::kFloat32);
+        torch::Tensor gradFilterBias = torch::empty({rows}, torch::kFloat32);
+
+        float* gradFilterWeights_ptr = gradFilterWeights.data_ptr<float>();
+        float* gradFilterBias_ptr = gradFilterBias.data_ptr<float>();
+
+        std::unique_ptr<float[]> localDerivativeOfFilterOutput(new float[tree->getNumNodes()]);
+        for (NodeId nodeId : tree->getNodeIds()) {
+            float dSigmoid = sigmoid_ptr[nodeId] * (1 - sigmoid_ptr[nodeId]);
+            float residue = tree->getParentById(nodeId) != InvalidNode ? tree->getResidueById(nodeId) : 0;
+
+            // Calcula o gradiente local para cada nó
+            localDerivativeOfFilterOutput[nodeId] = residue * dSigmoid;
+
+            // Calcula o gradiente do filtro para os pesos e bias
+            gradFilterBias_ptr[nodeId] = localDerivativeOfFilterOutput[nodeId];
+            for (int j = 0; j < cols; j++) {
+                gradFilterWeights_ptr[nodeId * cols + j] = localDerivativeOfFilterOutput[nodeId] * attributes[nodeId * cols + j];  // row-major //attributes[j * rows + nodeId];
+            }
+        }
+
+        torch::Tensor gradWeight = torch::zeros({cols}, torch::kFloat32);
+        torch::Tensor gradBias = torch::zeros({1}, torch::kFloat32);
+
+        float* gradWeight_ptr = gradWeight.data_ptr<float>();
+        float* gradBias_ptr = gradBias.data_ptr<float>();
+        float* gradLoss = gradientOfLoss.data_ptr<float>();
+
+        // Vamos somar os gradientes da loss de cada CC e acumular com o gradiente local.
+        std::unique_ptr<float[]> summationGrad_ptr(new float[tree->getNumNodes()]);
+        AttributeComputedIncrementally::computerAttribute(
+            tree,
+            tree->getRootById(),
+            [&](NodeId nodeId) -> void { // pre-processing
+                summationGrad_ptr[nodeId] = 0;
+                for (int p : tree->getCNPsById(nodeId)) {
+                    summationGrad_ptr[nodeId] += gradLoss[p];
+                }
+            },
+            [&summationGrad_ptr](NodeId parent, NodeId child) -> void { // merge-processing
+                summationGrad_ptr[parent] += summationGrad_ptr[child];
+            },
+            [&](NodeId nodeId) -> void { // post-processing                
+                gradBias_ptr[0] += summationGrad_ptr[nodeId] * gradFilterBias_ptr[nodeId];
+                for (int j = 0; j < cols; j++) {
+                    gradWeight_ptr[j] += summationGrad_ptr[nodeId] * gradFilterWeights_ptr[nodeId * cols + j];
+                }
+            }
+        );
+
+
+        return std::make_tuple(gradWeight, gradBias);
+    }
+    
+
+    /**
+     * Gradiente apenas para o parâmetro escalar "threshold".
+     *
+     * Assumimos que o forward foi:
+     *    logits_i = attribute_i - threshold
+     *    sigmoid_i = 1 / (1 + exp(-logits_i))
+     *    y = filtering(tree, sigmoid)
+     *
+     * Então:
+     *    d(sigmoid_i)/d(threshold) = - sigmoid_i * (1 - sigmoid_i)
+     *    d(y)/d(sigmoid_i) = residue_i 
+     *    dLoss/dthreshold = sum_nodes [ sum_pixels_in_CC( dLoss/dy[p] ) * residue_i * d(sigmoid_i)/d(threshold) ]
+     *
+     * Parâmetros:
+     *   - treePtr: árvore
+     *   - sigmoid: tensor 1D (numNodes) float32
+     *   - gradientOfLoss: gradiente da loss no domínio da imagem (H x W), float32
+     *
+     * Retorno:
+     *   - gradThreshold: tensor (1,) float32
+     */
+    static torch::Tensor gradientsOfThreshold(MorphologicalTreePybindPtr treePtr, torch::Tensor sigmoid, float beta, torch::Tensor gradientOfLoss) {
+        MorphologicalTreePybind* tree = treePtr.get();
+        float* sigmoid_ptr = sigmoid.data_ptr<float>();
+        float* gradLoss = gradientOfLoss.data_ptr<float>();
+
+        // Derivada local d y / d threshold por nó
+        std::unique_ptr<float[]> localDerivativeOfFilterOutput(new float[tree->getNumNodes()]);
+
+        // Primeiro, computamos a derivada local:
+        // localDerivativeOfFilterOutput[node] = residue(node) * d(sigmoid)/d(threshold)
+        // d(sigmoid)/d(threshold) = -beta * sigmoid * (1 - sigmoid)
+        for (NodeId nodeId : tree->getNodeIds()) {
+            float residue = (tree->getParentById(nodeId) != InvalidNode) ? static_cast<float>(tree->getResidueById(nodeId)) : 0.0f;
+            float dSigmoid = -beta * sigmoid_ptr[nodeId] * (1 - sigmoid_ptr[nodeId]);
+            localDerivativeOfFilterOutput[nodeId] = residue * dSigmoid;
+        }
+
+        torch::Tensor gradThreshold = torch::zeros({1}, torch::kFloat32);
+        float* gthr = gradThreshold.data_ptr<float>();
+        gthr[0] = 0.0f;
+
+        // Agora, somamos dLoss/dy(p) por nó (somando nos pixels pertencentes à CC do nó)
+        std::unique_ptr<float[]> sumGradPerNode(new float[tree->getNumNodes()]);
+        AttributeComputedIncrementally::computerAttribute(
+            tree,
+            tree->getRootById(),
+            [&](NodeId nodeId) -> void { // pre-processing
+                sumGradPerNode[nodeId] = 0.0f;
+                for (int p : tree->getCNPsById(nodeId)) {
+                    sumGradPerNode[nodeId] += gradLoss[p];
+                }
+            },
+            [&](NodeId parent, NodeId child) -> void { // merge-processing
+                sumGradPerNode[parent] += sumGradPerNode[child];
+            },
+            [&](NodeId nodeId) -> void { 
+                gthr[0] += sumGradPerNode[nodeId] * localDerivativeOfFilterOutput[nodeId];
+            }
+        );
+
+        return gradThreshold;
+    }
+
+    // Gradiente para K parâmetros (um threshold por atributo do grupo).
+    // Entradas:
+    //   - sigmoids2d: tensor 2D (numNodes, K) float32 com σ_{ik} do forward
+    //   - gradientOfLoss: tensor 2D (H, W) float32 com dLoss/dy
+    // Saída:
+    //   - gradThresholds: tensor 1D (K,) float32 com dLoss/dτ_k
+    static torch::Tensor gradientsOfThresholds(MorphologicalTreePybindPtr treePtr, torch::Tensor sigmoids2d, float beta, torch::Tensor gradientOfLoss) {
+        MorphologicalTreePybind* tree = treePtr.get();
+
+        //--- checagens básicas ---
+        TORCH_CHECK(sigmoids2d.dim() == 2, "sigmoids2d deve ter shape (numNodes, K).");
+        TORCH_CHECK(sigmoids2d.dtype() == torch::kFloat32, "sigmoids2d deve ser float32.");
+        TORCH_CHECK(gradientOfLoss.dim() == 2, "gradientOfLoss deve ter shape (H, W).");
+        TORCH_CHECK(gradientOfLoss.dtype() == torch::kFloat32, "gradientOfLoss deve ser float32.");
+
+        const int64_t numNodes = sigmoids2d.size(0);
+        const int64_t K        = sigmoids2d.size(1);
+        const float* sigmoids2d_ptr = sigmoids2d.data_ptr<float>();
+
+        // 1) Derivada local por nó e por parâmetro:
+        //    localDerivativeOfFilterOutput[i,k] = residue_i * ( - s_i * (1 - s_i) )
+        const size_t localSize = static_cast<size_t>(numNodes) * static_cast<size_t>(K);
+        std::unique_ptr<float[]> localDerivativeOfFilterOutput(new float[localSize]);
+        float* localDerivativeOfFilterOutput_ptr = localDerivativeOfFilterOutput.get();
+
+        for (NodeId nodeId : tree->getNodeIds()) {
+            float residue = (tree->getParentById(nodeId) != InvalidNode) ? static_cast<float>(tree->getResidueById(nodeId)) : 0.0f;
+            float* dst = localDerivativeOfFilterOutput_ptr + static_cast<int64_t>(nodeId) * K;
+            const float* sigmoids_nodeId = sigmoids2d_ptr + static_cast<int64_t>(nodeId) * K;
+            for (int64_t k = 0; k < K; ++k) {
+                dst[k] = residue * (-beta * sigmoids_nodeId[k] * (1.0f - sigmoids_nodeId[k]) );
+            }
+        }
+
+        // 2) Somatório de dLoss/dy por CC e agregação final
+        float* gradLoss = gradientOfLoss.data_ptr<float>();
+        std::unique_ptr<float[]> sumGradPerNode(new float[static_cast<size_t>(numNodes)]);
+        auto gradThresholds = torch::zeros({K}, torch::kFloat32);
+        float* gthr = gradThresholds.data_ptr<float>();
+
+        AttributeComputedIncrementally::computerAttribute(
+            tree,
+            tree->getRootById(),
+            [&](NodeId nodeId) -> void { // pre-processing
+                sumGradPerNode[nodeId] = 0.0f;
+                for (int p : tree->getCNPsById(nodeId)) {
+                    sumGradPerNode[nodeId] += gradLoss[p];
+                }
+            },
+            [&](NodeId parent, NodeId child) -> void { // merge-processing
+                sumGradPerNode[parent] += sumGradPerNode[child];
+            },
+            [&](NodeId nodeId) -> void { // post-processing
+                const float acc = sumGradPerNode[nodeId]; // dL/dy somado nos pixels do nó/CC
+                const float* loc = localDerivativeOfFilterOutput_ptr + static_cast<int64_t>(nodeId) * K;
+                for (int64_t k = 0; k < K; ++k) {
+                    gthr[k] += acc * loc[k];
+                }
+            }
+        );
+
+        return gradThresholds; // (K,)
+    }
+
+    
+
+};
+
+} // namespace mtlearn

mtlearn-0.1.4/bindings/.ipynb_checkpoints/InfoTreePybind-checkpoint.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+
+#include <mmcfilters/attributes/AttributeComputedIncrementally.hpp>
+#include <mmcfilters/trees/NodeMT.hpp>
+#include <mmcfilters/trees/MorphologicalTree.hpp>
+#include <mmcfilters/utils/Common.hpp>
+
+#include "MorphologicalTreePybind.hpp"
+#include "PybindTorchUtils.hpp"
+
+#include <memory>
+#include <vector>
+#include <tuple>
+
+#include <pybind11/pybind11.h>
+#include <torch/extension.h>
+#include <ATen/ops/_sparse_mm.h>
+
+
+
+namespace mtlearn {
+
+namespace py = pybind11;
+
+using mmcfilters::AttributeComputedIncrementally;
+using mmcfilters::InvalidNode;
+using mmcfilters::MorphologicalTreePybindPtr;
+using mmcfilters::NodeId;
+
+class InfoTreePybind {
+public:
+
+    
+    static torch::Tensor getResidues(MorphologicalTreePybindPtr tree) {
+        if (!tree) {
+            throw py::value_error("MorphologicalTreePybindPtr inválido");
+        }
+
+        int numNodes = tree->getNumNodes();
+        float* residues = new float[numNodes];
+
+        for (NodeId nodeId : tree->getNodeIds()) {
+            residues[nodeId] = static_cast<float>(tree->getResidueById(nodeId));
+        }
+
+        return PybindTorchUtils::toTensor(residues, numNodes);
+    }
+
+
+
+};
+
+} // namespace mtlearn

mtlearn-0.1.4/bindings/.ipynb_checkpoints/module-checkpoint.cpp

@@ -0,0 +1,128 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <torch/extension.h>
+
+#include "mtlearn/core.hpp"
+#include "ConnectedFilterByJacobian.hpp"
+#include "ConnectedFilterByMorphologicalTree.hpp"
+#include "InfoTreePybind.hpp"
+
+namespace py = pybind11;
+
+void init_ComputerDerivative(py::module& m){
+
+    py::class_<mtlearn::ConnectedFilterByJacobian>(m, "ConnectedFilterByJacobian")
+        .def_static(
+            "gradients",
+            &mtlearn::ConnectedFilterByJacobian::gradients,
+            py::arg("jacobian"),
+            py::arg("residues"),
+            py::arg("attributes"),
+            py::arg("sigmoid"),
+            py::arg("grad_output"),
+            "Aplica a jacobiana esparsa para projetar gradientes de nós para pixels.")
+        .def_static(
+            "filtering",
+            &mtlearn::ConnectedFilterByJacobian::filtering,
+            py::arg("pixel_to_node"),
+            py::arg("residues"),
+            py::arg("sigmoid"),
+            "Reconstrói a saída por pixel sem depender da árvore C++ completa.")
+        .def_static(
+            "compute_gradients_efficient",
+            &mtlearn::ConnectedFilterByJacobian::computeGradientsEfficient,
+            py::arg("pixel_to_node"),
+            py::arg("residues"),
+            py::arg("sigmoid"),
+            py::arg("attributes"),
+            py::arg("grad_output"),
+            "Gradientes otimizados usando apenas vetores auxiliares no PyTorch.");
+
+    py::class_<mtlearn::ConnectedFilterByMorphologicalTree>(m, "ConnectedFilterByMorphologicalTree")
+        .def_static(
+            "filtering",
+            &mtlearn::ConnectedFilterByMorphologicalTree::filtering,
+            py::arg("tree"),
+            py::arg("sigmoid"),
+            "Reconstrói a imagem filtrada.")
+        // --- gradientes p/ pesos e bias (assinatura antiga, 4 args) ---
+        .def_static(
+            "gradients",
+            &mtlearn::ConnectedFilterByMorphologicalTree::gradients,
+            py::arg("tree"),
+            py::arg("attributes"),
+            py::arg("sigmoid"),
+            py::arg("grad_output"),
+            "Calcula gradientes de weight e bias a partir da estrutura da árvore."
+        )
+        // --- gradiente p/ thresholds
+        .def_static(
+            "gradientsOfThresholds",
+            &mtlearn::ConnectedFilterByMorphologicalTree::gradientsOfThresholds,
+            py::arg("tree"),
+            py::arg("sigmoid"),
+            py::arg("beta"),
+            py::arg("grad_output"),
+            "Calcula gradiente dos thresholds (logits = attributes - thresholds)."
+        )
+        // --- gradiente p/ 1 threshold
+        .def_static(
+            "gradientsOfThreshold",
+            &mtlearn::ConnectedFilterByMorphologicalTree::gradientsOfThreshold,
+            py::arg("tree"),
+            py::arg("sigmoid"),
+            py::arg("beta"),
+            py::arg("grad_output"),
+            "Calcula gradiente apenas de um threshold (logits = attribute - threshold)."
+        );
+}
+
+void init_InfoTree(py::module& m)
+{
+
+    py::class_<mtlearn::InfoTreePybind>(m, "InfoTree")
+        .def_static(
+            "get_residues",
+            &mtlearn::InfoTreePybind::getResidues,
+            py::arg("tree"),
+            "Obtém os resíduos de todos os nós da árvore como um tensor.");
+}
+
+void init_tests(py::module& m)
+{
+    py::class_<mtlearn::TreeStats>(m, "TreeStats")
+        .def(py::init<>())
+        .def_readwrite("num_nodes", &mtlearn::TreeStats::numNodes)
+        .def("describe", [](const mtlearn::TreeStats& stats) {
+            return mtlearn::describeTree(stats);
+        });
+
+    m.def(
+        "make_tree_stats",
+        [](int numNodes) {
+            return mtlearn::makeTreeStats(numNodes);
+        },
+        py::arg("num_nodes"),
+        "Create a simple TreeStats instance using a node count.");
+
+    m.def(
+        "make_tree_tensor",
+        [](int numNodes) {
+            auto stats = mtlearn::makeTreeStats(numNodes);
+            auto tensor = torch::arange(numNodes, torch::dtype(torch::kFloat32));
+            return py::make_tuple(stats, tensor);
+        },
+        py::arg("num_nodes"),
+        "Return TreeStats and a torch tensor with a simple range.");
+
+
+}
+
+PYBIND11_MODULE(_mtlearn, m)
+{
+    m.doc() = "Python bindings for MTLearn built on top of mmcfilters";
+    m.attr("WITH_TORCH") = true;
+    init_ComputerDerivative(m);
+    init_InfoTree(m);
+    init_tests(m);
+}

{mtlearn-0.1.2 → mtlearn-0.1.4}/bindings/CMakeLists.txt

@@ -19,14 +19,31 @@ find_package(Python3 COMPONENTS Interpreter QUIET)
 if(MTLEARN_WITH_TORCH)
     find_package(Torch REQUIRED)
     pybind11_add_module(_mtlearn module.cpp)
-    target_link_libraries(_mtlearn PRIVATE mtlearn::core ${TORCH_LIBRARIES})
-    target_include_directories(_mtlearn PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../src ${TORCH_INCLUDE_DIRS})
+    # Filtra libs não encontradas do Torch antes de linkar
+    if(UNIX AND NOT APPLE)
+        set(FILTERED_TORCH_LIBRARIES "")
+        foreach(lib ${TORCH_LIBRARIES})
+            if(NOT lib MATCHES "-NOTFOUND$")
+                list(APPEND FILTERED_TORCH_LIBRARIES ${lib})
+            endif()
+        endforeach()
+        target_link_libraries(_mtlearn PRIVATE mtlearn::core mmcfilters::core ${FILTERED_TORCH_LIBRARIES})
+    elseif(APPLE)
+        target_link_libraries(_mtlearn PRIVATE mtlearn::core mmcfilters::core ${TORCH_LIBRARIES})
+    endif()
+
+    get_filename_component(_torch_root "${TORCH_LIBRARY}" DIRECTORY)
+    find_library(TORCH_PYTHON_LIBRARY torch_python
+        HINTS "${_torch_root}" "${_torch_root}/.." "${_torch_root}/../.."
+        PATH_SUFFIXES lib)
+    if(TORCH_PYTHON_LIBRARY)
+        target_link_libraries(_mtlearn PRIVATE "${TORCH_PYTHON_LIBRARY}")
+    endif()
+    target_include_directories(_mtlearn PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/../src
+        ${TORCH_INCLUDE_DIRS}
+        ${CMAKE_SOURCE_DIR}/external/MorphologicalAttributeFilters/pybinds)
     target_compile_definitions(_mtlearn PRIVATE MTLEARN_WITH_TORCH=1)
-else()
-    pybind11_add_module(_mtlearn module_stub.cpp)
-    target_link_libraries(_mtlearn PRIVATE mtlearn::core)
-    target_include_directories(_mtlearn PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../src)
-    target_compile_definitions(_mtlearn PRIVATE MTLEARN_WITH_TORCH=0)
 endif()
 
 set_target_properties(_mtlearn PROPERTIES OUTPUT_NAME "_mtlearn")