⚡️ Speed up function compose_transformations by 25%

[codeflash-ai]

📄 25% (0.25x) speedup for compose_transformations in kornia/geometry/linalg.py

⏱️ Runtime : 1.50 millisecond → 1.20 millisecond (best of 138 runs)

📝 Explanation and details

Certainly! Here are some optimizations to improve the runtime performance in your program.

1. Efficient Tensor Initialization: Avoid using zeros_like which always initializes the entire tensor. Instead, directly copy the input transformation matrices and modify only the required elements. This avoids unnecessary memory operations on elements that remain unchanged.

2. Simplified Multiplications for Static Elements: Use direct assignment for setting constant values like 1.0 rather than adding them to zero matrices, which is computationally more expensive.

Here's the optimized code.

This optimized version avoids unnecessary memory operations and uses direct assignments for known static values, improving both the speed and the clarity of the function.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 38 Passed
🌀 Generated Regression Tests	✅ 14 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	94.7%

⚙️ Existing Unit Tests Details

- geometry/test_linalg.py

🌀 Generated Regression Tests Details

import pytest  # used for our unit tests
import torch
from kornia.core import zeros_like
from kornia.geometry.linalg import compose_transformations
from torch import Tensor


# unit tests
def test_compose_transformations_identity():
    # Test with identity matrices
    trans_01 = torch.eye(4)
    trans_12 = torch.eye(4)
    codeflash_output = compose_transformations(trans_01, trans_12)

def test_compose_transformations_basic_translation():
    # Test with simple translation matrices
    trans_01 = torch.eye(4)
    trans_01[0, 3] = 1  # Translate by 1 along x-axis
    trans_12 = torch.eye(4)
    trans_12[1, 3] = 1  # Translate by 1 along y-axis
    codeflash_output = compose_transformations(trans_01, trans_12)
    expected = torch.eye(4)
    expected[0, 3] = 1
    expected[1, 3] = 1

def test_compose_transformations_batch():
    # Test with a batch of identity matrices
    N = 10
    trans_01 = torch.eye(4).repeat(N, 1, 1)
    trans_12 = torch.eye(4).repeat(N, 1, 1)
    codeflash_output = compose_transformations(trans_01, trans_12)

def test_compose_transformations_mismatched_dims():
    # Test with mismatched dimensions
    trans_01 = torch.eye(4)
    trans_12 = torch.eye(4).repeat(5, 1, 1)
    with pytest.raises(ValueError):
        compose_transformations(trans_01, trans_12)

def test_compose_transformations_non_tensor_input():
    # Test with non-tensor inputs
    trans_01 = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
    trans_12 = torch.eye(4)
    with pytest.raises(TypeError):
        compose_transformations(trans_01, trans_12)

def test_compose_transformations_large_batch():
    # Test with a large batch size
    N = 1000
    trans_01 = torch.eye(4).repeat(N, 1, 1)
    trans_12 = torch.eye(4).repeat(N, 1, 1)
    codeflash_output = compose_transformations(trans_01, trans_12)

def test_compose_transformations_inverse():
    # Test with a transformation and its inverse
    trans_01 = torch.eye(4)
    trans_01[0, 3] = 1
    trans_12 = torch.eye(4)
    trans_12[0, 3] = -1
    codeflash_output = compose_transformations(trans_01, trans_12)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
import torch
from kornia.geometry.linalg import compose_transformations
from torch import Tensor


# unit tests
def test_identity_matrices():
    # Test with identity matrices
    trans_01 = torch.eye(4)
    trans_12 = torch.eye(4)
    expected = torch.eye(4)
    codeflash_output = compose_transformations(trans_01, trans_12)

def test_simple_translation():
    # Test with simple translation matrices
    trans_01 = torch.tensor([[1, 0, 0, 1],
                             [0, 1, 0, 0],
                             [0, 0, 1, 0],
                             [0, 0, 0, 1]], dtype=torch.float32)
    trans_12 = torch.tensor([[1, 0, 0, 2],
                             [0, 1, 0, 0],
                             [0, 0, 1, 0],
                             [0, 0, 0, 1]], dtype=torch.float32)
    expected = torch.tensor([[1, 0, 0, 3],
                             [0, 1, 0, 0],
                             [0, 0, 1, 0],
                             [0, 0, 0, 1]], dtype=torch.float32)
    codeflash_output = compose_transformations(trans_01, trans_12)

def test_invalid_shape():
    # Test with invalid shape
    trans_01 = torch.rand(3, 3)
    trans_12 = torch.eye(4)
    with pytest.raises(ValueError):
        compose_transformations(trans_01, trans_12)


def test_large_batch_size():
    # Test with a large batch size
    N = 1000  # Ensure it doesn't exceed 100MB
    trans_01 = torch.eye(4).unsqueeze(0).repeat(N, 1, 1)
    trans_12 = torch.eye(4).unsqueeze(0).repeat(N, 1, 1)
    expected = torch.eye(4).unsqueeze(0).repeat(N, 1, 1)
    codeflash_output = compose_transformations(trans_01, trans_12)

def test_non_tensor_input():
    # Test with non-tensor input
    trans_01 = [[1, 0, 0, 0],
                [0, 1, 0, 0],
                [0, 0, 1, 0],
                [0, 0, 0, 1]]
    trans_12 = torch.eye(4)
    with pytest.raises(TypeError):
        compose_transformations(trans_01, trans_12)

def test_negative_translation():
    # Test with negative translation
    trans_01 = torch.tensor([[1, 0, 0, -1],
                             [0, 1, 0, 0],
                             [0, 0, 1, 0],
                             [0, 0, 0, 1]], dtype=torch.float32)
    trans_12 = torch.tensor([[1, 0, 0, -2],
                             [0, 1, 0, 0],
                             [0, 0, 1, 0],
                             [0, 0, 0, 1]], dtype=torch.float32)
    expected = torch.tensor([[1, 0, 0, -3],
                             [0, 1, 0, 0],
                             [0, 0, 1, 0],
                             [0, 0, 0, 1]], dtype=torch.float32)
    codeflash_output = compose_transformations(trans_01, trans_12)

def test_floating_point_precision():
    # Test with small floating-point numbers
    trans_01 = torch.tensor([[1, 0, 0, 1e-7],
                             [0, 1, 0, 0],
                             [0, 0, 1, 0],
                             [0, 0, 0, 1]], dtype=torch.float32)
    trans_12 = torch.tensor([[1, 0, 0, 2e-7],
                             [0, 1, 0, 0],
                             [0, 0, 1, 0],
                             [0, 0, 0, 1]], dtype=torch.float32)
    expected = torch.tensor([[1, 0, 0, 3e-7],
                             [0, 1, 0, 0],
                             [0, 0, 1, 0],
                             [0, 0, 0, 1]], dtype=torch.float32)
    codeflash_output = compose_transformations(trans_01, trans_12)

To edit these changes git checkout codeflash/optimize-compose_transformations-m8objv5w and push.

[github-actions]

This pull request has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs within 7 days. Thank you for your contributions!