- Remove hard torch dependency

- Tweaking geotop

Author: Leguark

gempy_engine/modules/activator/activator_interface.py

@@ -85,39 +85,8 @@ def activate_formation_block_from_args_hard_sigmoid(Z_x, ids, scalar_value_at_sp
     return sigm.reshape(1, -1)
 
 
-import torch
 
 
-class HardSigmoidModified2(torch.autograd.Function):
-    @staticmethod
-    def forward(ctx, input, a, b, id):
-        ctx.save_for_backward(input)
-        ctx.bounds = (a, b)
-        ctx.id = id
-        output = bt.t.zeros_like(input)
-        slope_up = 1 / (b - a)
-
-        # For x in the range [a, b]
-        b_ = (input > a) & (input <= b)
-        pos = slope_up * (input[b_] - a)
-
-        output[b_] = id + pos
-
-        return output
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        input = ctx.saved_tensors[0]
-        a, b = ctx.bounds
-        slope_up = 1 / (b - a)
-
-        b_ = (input > a) & (input <= b)
-
-        grad_input = grad_output.clone()
-        # Apply gradient only within the range [a, b]
-        grad_input[b_] = grad_input[b_] * slope_up
-
-        return grad_input, None, None, None
 
 
 def _compute_sigmoid(Z_x, scale_0, scale_1, drift_0, drift_1, drift_id, sigmoid_slope):
@@ -138,108 +107,3 @@ def _compute_sigmoid(Z_x, scale_0, scale_1, drift_0, drift_1, drift_id, sigmoid_
 
     sigm = activation_sig + drift_id.reshape((-1, 1))
     return sigm
-
-
-def _add_relu():
-    # ReLU_up = T.switch(Z_x < scalar_field_iter[1], 0,
-    #                    - 0.01 * (Z_x - scalar_field_iter[1]))
-    # ReLU_down = T.switch(Z_x > scalar_field_iter[-2], 0,
-    #                      0.01 * T.abs_(Z_x - scalar_field_iter[-2]))
-    # formations_block += ReLU_down + ReLU_up
-    pass
-
-
-# * This gets the scalar gradient
-
-
-class HardSigmoidModified(torch.autograd.Function):
-    @staticmethod
-    def forward(ctx, input, a, b, id):
-        ctx.save_for_backward(input)
-        ctx.bounds = (a, b)
-        output = torch.zeros_like(input)
-        slope_up = 100 / (b - a)
-        midpoint = (a + b) / 2
-
-        # For x in the range [a, b]
-        b_ = (input > a) & (input <= b)
-
-        pos = slope_up * (input[b_] - a)
-
-        neg = -slope_up * (input[b_] - b)
-
-        print("Max min:", pos.max(), pos.min())
-        foo = id * pos - (id - 1) * neg
-
-        # output[b_] = id * pos
-        output[b_] = id + pos
-
-        # output[(input >= a) & (input <= b)] = torch.clamp(neg, min=0, max=1)
-        # output[(input >= a) & (input <= b)] = torch.clamp(pos + neg, min=0, max=1)
-        # output[(input >= a) & (input <= b)] = torch.clamp(pos + neg, min=0, max=1)
-
-        # Clamping the values outside the range [a, c] to zero
-        # output[input < a] = 0
-        # output[input >= b] = 0
-
-        # output[b_] *= id
-
-        return output
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        input, = ctx.saved_tensors
-        a, b = ctx.bounds
-        midpoint = (a + b) / 2
-        grad_input = grad_output.clone()
-
-        # Gradient is 1/(b-a) for x in [a, midpoint), -1/(b-a) for x in (midpoint, b], and 0 elsewhere
-        grad_input[input < a] = 0
-        grad_input[input > b] = 0
-        grad_input[(input >= a) & (input < midpoint)] = 1 / (b - a)
-        grad_input[(input > midpoint) & (input <= b)] = -1 / (b - a)
-
-        return grad_input, None, None, None
-
-
-class HardSigmoid(torch.autograd.Function):
-    @staticmethod
-    def forward(ctx, input, a, b, c):
-        ctx.save_for_backward(input)
-        ctx.bounds = (a, b)
-        slope = 1 / (b - a)
-        return torch.clamp(slope * (input - a) + 0.5, min=0, max=1)
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        input, = ctx.saved_tensors
-        a, b = ctx.bounds
-        grad_input = grad_output.clone()
-        grad_input[input < a] = 0
-        grad_input[input > b] = 0
-        grad_input[(input >= a) & (input <= b)] = 1 / (b - a)
-        return grad_input, None, None
-
-
-class CustomSigmoidFunction(torch.autograd.Function):
-    @staticmethod
-    def forward(ctx, Z_x, scale_0, scale_1, drift_0, drift_1, drift_id, sigmoid_slope, epsilon=1e-7):
-        sigmoid_slope_tensor = sigmoid_slope
-
-        active_sig = -scale_0 / (1 + torch.exp(-sigmoid_slope_tensor * (Z_x - drift_0)).clamp(min=epsilon))
-        deactive_sig = -scale_1 / (1 + torch.exp(sigmoid_slope_tensor * (Z_x - drift_1)).clamp(min=epsilon))
-        activation_sig = active_sig + deactive_sig
-
-        sigm = activation_sig + drift_id
-
-        ctx.save_for_backward(sigm)
-        return sigm
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        sigm, = ctx.saved_tensors
-        # Here you need to compute the actual gradient of your function with respect to the inputs.
-        # The following is just a placeholder to illustrate replacing NaNs with zeros.
-        # grad_input = torch.nan_to_num(grad_output)  # Replace NaNs with zeros
-        # Do the actual gradient computation here
-        return grad_output, None, None, None, None, None, None