diff --git a/fn_gen/nlr_t_no_sched/0/distortion.png b/fn_gen/nlr_t_no_sched/0/distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..45c3a7820b84815a8a1db913391408986173ccf6
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/0/distortion.png differ
diff --git a/fn_gen/nlr_t_no_sched/0/expressions.txt b/fn_gen/nlr_t_no_sched/0/expressions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0a7e5be4566beeb4727d82f95d24241966d158dc
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/0/expressions.txt
@@ -0,0 +1,2 @@
+log(_0*x)/_s
+exp(_s*x)/_0
\ No newline at end of file
diff --git a/fn_gen/nlr_t_no_sched/0/fn.py b/fn_gen/nlr_t_no_sched/0/fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..92fe1e88e957df0f71e3a68f4b2534a2d52e8c63
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/0/fn.py
@@ -0,0 +1,479 @@
+from __future__ import annotations
+
+import torch
+from torch import amin  # Necessary for arcsin
+import copy
+import torch.nn as nn
+import numpy as np
+
+from scipy.optimize import curve_fit
+from typing import Dict, Any, Tuple, List, Callable
+
+
+def quantization(x, **params):
+	return (torch.div(1, replace_num(params['_s'], num=0, to=10000)) * torch.log(domain_guard((params['_0'] * x), min=1e-5, nan=1e-5)))
+
+
+def dequantization(x, **params):
+	return (torch.div(1, replace_num(params['_0'], num=0, to=10000)) * torch.exp((params['_s'] * x)))
+
+
+def init_params(x: torch.Tensor, **kwargs: Dict[str, Any]) -> Dict[str, nn.Parameter]:
+	base_p0 = {
+	'_0': init_space_search(x, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], param='_0', **kwargs),
+	}
+
+	base_p0['_s'] = init_linear_scale(x, qtz_func=quantization, params=base_p0, **kwargs)
+	if 'post_init_hook' in kwargs:
+		kwargs['post_init_hook'](parameters=base_p0)
+	
+	params = init_non_linear_regression_fit(x, p0=base_p0, np_fit_func=fit_func, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], **kwargs)
+	params = {k: nn.Parameter(v, requires_grad=False) for k, v in params.items()}
+	if 'post_method_hook' in kwargs:
+		kwargs['post_method_hook'](parameters=params)
+	
+	params = learn_parameters(x, params,
+		qtz_func=quantization,
+		deqtz_func=dequantization,
+		bits=kwargs['bits'],
+		target_dtype=torch.int8,
+		epochs=500,
+		early_stop=False,
+	)
+	if 'post_train_hook' in kwargs:
+		kwargs['post_train_hook'](parameters=params)
+	
+	return params
+
+
+############### Numpy Qtz ###############
+
+
+def np_quantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_s, num=0, to=10000)) * np.log(np_domain_guard((_0 * x), min=1e-5, nan=1e-5)))
+
+
+def np_dequantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_0, num=0, to=10000)) * np.exp((_s * x)))
+
+
+def fit_func(x, _0, _s):
+    x_ = np_quantization(x, _0, _s)
+    x_ = np_dequantization(x_, _0, _s)
+    return x_
+
+
+
+############### HELPERS ###############
+
+def domain_guard(
+        x: torch.Tensor, 
+        min: float = None, 
+        max: float = None, 
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> torch.Tensor:
+    """Guard a tensor to a valid domain."""
+    x = torch.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = torch.clamp(x, min=min, max=max)
+    return x
+
+
+def replace_num(x: torch.Tensor, num: float, to: float) -> torch.Tensor:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (torch.Tensor): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        torch.Tensor: The tensor with the number replaced.
+    """
+    return torch.where(x == num, to, x)
+
+
+def guarded_torch_power(x: torch.Tensor, exp: float) -> torch.Tensor:
+    """Guard the power operation to a valid domain."""
+    return torch.pow(x, exp) if exp >= 1 else torch.pow(torch.relu(x), exp)
+
+
+def init_ones(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.ones_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_rand(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.randn_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_space_search(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    def _build_initial_param(tensor: torch.Tensor, max_initial: int, n_params: int):
+        """Generates the initial set of parameters. The first iteration generates 10 times more parameters."""
+        for _ in range(n_params * 10):  # The first iteration generates 10 times more parameters
+            yield init_rand(tensor) * max_initial  # Generates n_params in range [-max_initial, max_initial]
+
+    def _search_param(tensors: List[torch.tensor], n_params):
+        """Takes the best parameters and generates new parameters around the mean of the best parameters."""
+        torch_tensors = torch.stack(tensors)
+        min_vals, max_vals = torch.aminmax(torch_tensors, dim=0)
+        abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+        mean = torch.mean(torch_tensors, dim=0)
+        for _ in range(n_params):  # Generates n_params around the mean of the tensors
+            yield torch.randn_like(min_vals) * abs_max_val_per_ch + mean
+
+    def _calc(x, qtz_func, deqtz_func, **params):
+        x_ = x.transpose(0, 1)
+        x_ = qtz_func(x=x_, **params)
+        x_ = deqtz_func(x=x_, **params)
+        x_ = x_.transpose(0, 1)
+        return x_
+
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+    assert "deqtz_func" in kwargs, "deqtz_func must be provided."
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "param" in kwargs, "param must be provided."
+
+    qtz_func = kwargs.get('qtz_func')
+    deqtz_func = kwargs.get('deqtz_func')
+    params_list = kwargs.get('params_list')
+    param = kwargs.get('param')
+
+    n_runs = 50                # Number of runs to try to find the best parameters
+    n_random_params = 50       # Number of random parameters to generate
+    n_best_to_pick = 5         # Number of best parameters to pick after each run
+    max_initial = 10000        # Maximum value to initialize the parameters
+
+    # Initializes the parameters
+    base_params = { p: init_ones(x, **kwargs) for p in params_list if p != param }
+    params = _build_initial_param(x, max_initial, n_random_params)
+
+    # Performs the search
+    for _ in range(n_runs):
+        
+        best_params = []
+        for param_ in params:
+            try:
+                x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: param_})
+                loss_ones = nn.MSELoss()(x, x_)
+
+                if len(best_params) < n_best_to_pick:
+                    best_params.append((param_, loss_ones.item()))
+                    best_params = sorted(best_params, key=lambda x: x[1])
+                elif loss_ones < best_params[-1][1]:
+                    best_params[-1] = (param_, loss_ones.item())
+                    best_params = sorted(best_params, key=lambda x: x[1])
+
+            except Exception:  # The parameters might not be valid for the function's domain
+                continue
+
+        # Generates new parameters around the mean
+        params = _search_param([p for p, _ in best_params], n_random_params)
+
+    # Checks if the best parameter is better than the init_ones
+    p_ones = init_ones(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_ones})
+    loss_ones = nn.MSELoss()(x, x_)
+
+    # Checks if the best parameter is better than the init_rand
+    p_rand = init_rand(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_rand})
+    loss_rand = nn.MSELoss()(x, x_)
+
+    if loss_rand < best_params[0][1] and loss_rand < loss_ones:
+        return p_rand
+    elif loss_ones < best_params[0][1] and loss_ones < loss_rand:
+        return p_ones
+    else:
+        return best_params[0][0]
+
+
+def init_linear_scale(  # Symmetric scale. From the study folder
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+    assert "bits" in kwargs, "bits must be provided."
+    assert "params" in kwargs, "params must be provided."
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+
+    bits = kwargs.get('bits')
+    params = kwargs.get('params')
+    qtz_func = kwargs.get('qtz_func')
+
+    x_ = x.transpose(0, 1)
+    x_ = qtz_func(x=x_, **params, _s=init_ones(x, **kwargs))
+    x_ = x_.transpose(0, 1)
+    
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    min_vals, max_vals = torch.aminmax(x_, dim=1)
+    min_vals = torch.min(min_vals, torch.zeros_like(min_vals))
+    max_vals = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    eps = torch.finfo(torch.float32).eps
+
+    abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+    scale = abs_max_val_per_ch / (float(quant_max - quant_min) / 2)
+    
+    scale = torch.clamp(scale, min=eps).to(dtype=torch.float32, device=min_vals.device)
+
+    # Introduces some noise in scale
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything.
+    # NOTE(diogo): This has been disproven. The noise does not help the learning process but I still
+    # left it here for future reference. Will be removed later.
+    # scale = scale + 0.01 * torch.randn_like(scale)
+
+    return scale
+
+
+def init_non_linear_regression_fit(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "np_fit_func" in kwargs, "np_fit_func must be provided."
+    assert "p0" in kwargs, "p0 must be provided."
+    np_fit_func = kwargs.get('np_fit_func')
+    params_list = kwargs.get('params_list')
+    p0 = kwargs.get('p0')
+
+    def _fit(xdata: np.ndarray, ydata: np.ndarray, func: Callable, p0: List[float]):
+        popt, _ = curve_fit(
+            func, 
+            xdata, 
+            ydata, 
+            maxfev=1000,
+            p0=p0,
+            method='lm'
+        )
+        return popt
+
+    # 1. Needs to convert the torch tensor to numpy tensor
+    xdata = x.cpu().numpy()
+
+    # 2. Sorts the data so that it makes it easier to fit to it
+    sorted_xdata = np.sort(xdata, axis=-1)
+
+    p0 = {k: v.cpu().numpy() for k, v in p0.items()}
+    params_list = sorted(params_list)  # We need to make sure that it matches the numpy fit func arg order
+
+    # 3. Finds the best parameters for each channel
+    try:
+        params = []
+        for i in range(sorted_xdata.shape[0]):
+            xdata_ = sorted_xdata[i]
+            p0_ = [p0[p][i] for p in params_list]
+            ch_params = _fit(xdata_, xdata_, np_fit_func, p0_)
+            params.append(ch_params)
+
+        # 4. Builds the parameters
+        result = {}
+        for i, p in enumerate(params_list):
+            result[p] = torch.tensor([p_[i] for p_ in params], dtype=torch.float32).to(x.device)
+
+        return result
+
+    except ValueError as e:
+        print(f"Could not fit the function with error: {e}")
+        print(f"Using fallback result...")
+        return {
+            k: torch.tensor(v, dtype=torch.float32).to(x.device) for k, v in p0.items()
+        }
+
+
+def init_zeros(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.zeros_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_inner_scale(tensor: torch.Tensor, _min: float = torch.inf, _max: float = torch.inf) -> torch.Tensor:
+    # Calculate the original minimum and maximum values
+    min_vals, max_vals = torch.aminmax(tensor, dim=-1)
+    x_min = torch.min(min_vals, torch.zeros_like(min_vals))
+    x_max = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    if _max is torch.inf:  # We do not need to scale the tensor. Just need to move it
+        return torch.ones_like(x_min)
+    
+    # Calculate the scale factor
+    scale = (_max - _min) / (x_max - x_min)
+    return scale
+
+
+
+############## Quant ###############
+
+@torch.enable_grad()
+def learn_parameters(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    qtz_func: nn.Module,
+    deqtz_func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype,
+    epochs: int = 1000,
+    early_stop: bool = True,
+    do_report: bool = False
+) -> Tuple[Dict[str, nn.Parameter], torch.Tensor]:
+    loss_fn = nn.MSELoss()
+
+    # Determines the initial learning rate by computing the initial loss and multiplying it by
+    # the order of magnitude of the loss divided by 2
+    quant = quantize(x, params, qtz_func, bits, target_dtype)
+    dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+    loss = loss_fn(x, dequant)
+
+    base_lr = 0.1
+    exponent = int(np.floor(np.log10(loss.item())))
+    lr = base_lr * (10 ** (exponent // 2))
+    
+    # Requires gradients in the parameters
+    for p in params.values():
+        p.requires_grad = True
+        p.grad = None
+
+    param_keys = list(params.keys())
+    param_values = list(params.values())
+
+    # Defines optimizer and loss function
+    optimizer = torch.optim.Adam(param_values, lr=lr)
+
+    # Contains the best loss and the best parameters 
+    best_loss = float("inf")
+    best_params = None
+
+    # Used to stop the search early
+    min_delta = 1e-7
+    acc_loss = []
+    percent_epochs_before_stop = 0.1
+
+    for i in range(epochs):
+        optimizer.zero_grad()
+
+        quant = quantize(x, params, qtz_func, bits, target_dtype)
+        dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+        loss = loss_fn(x, dequant)
+
+        if loss.isnan() or loss.isinf():
+            raise Exception("Loss is NaN or Inf. Stopping the search.")
+
+        loss.backward()
+        optimizer.step()
+
+        acc_loss.append(loss.item())
+
+        # Reports loss every 10 steps
+        if i % 10 == 0 and do_report:
+            print(f"Epoch {i}: Loss {loss.item()}")
+
+        # Optimizes the parameter search by storing the best loss and the parameters
+        if loss.item() < best_loss:
+            best_loss = loss.item()
+            best_params = copy.deepcopy({
+                k: v for k, v in params.items() if k in param_keys
+            })
+
+        # We also stop the search if the loss has not considerably during the last 10% epochs
+        if early_stop:
+            epochs_before_stop = int(epochs * percent_epochs_before_stop)
+            if i > epochs_before_stop and abs(acc_loss[i - epochs_before_stop] - acc_loss[i]) < min_delta:
+                break
+
+    # No longer requires gradients in the parameters
+    for p in best_params.values():
+        p.requires_grad = False
+        p.grad = None
+    
+    if do_report:
+        print(f"Best loss: {best_loss}")
+        return best_params, acc_loss
+    else:
+        return best_params
+
+
+def quantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype = torch.int8
+) -> torch.Tensor:
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    x = x.transpose(0, 1)  # Aligns shapes
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    x = torch.clamp(round_func_BPDA(x), quant_min, quant_max).to(target_dtype)
+    return x
+
+
+def dequantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    out_dtype: torch.dtype
+) -> torch.Tensor:
+    x = x.to(dtype=out_dtype)
+    x = x.transpose(0, 1)
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    return x
+
+
+def round_func_BPDA(input):
+    # This is equivalent to replacing round function (non-differentiable) with
+    # an identity function (differentiable) only when backward.
+    forward_value = torch.round(input)
+    out = input.clone()
+    out.data = forward_value.data
+    return out
+
+
+def get_min_max_from_bits_signed(bit_width: int) -> Tuple[int, int]:
+    return -2 ** (bit_width - 1), 2 ** (bit_width - 1) - 1
+
+
+
+############## Numpy ###############
+
+def np_domain_guard(
+        x: np.ndarray,
+        min: float = None,
+        max: float = None,
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> np.ndarray:
+    """Guard a tensor to a valid domain."""
+    x = np.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = np.clip(x, min, max)
+    return x
+
+
+def np_replace_num(x: np.ndarray, num: float, to: float) -> np.ndarray:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (np.ndarray): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        np.ndarray: The tensor with the number replaced.
+    """
+    return np.where(x == num, to, x)
+
+
+def np_guarded_power(x: np.ndarray, exp: float) -> np.ndarray:
+    """Guard the power operation to a valid domain."""
+    return np.power(x, exp) if exp >= 1 else np.power(np.maximum(x, 0), exp)
+
diff --git a/fn_gen/nlr_t_no_sched/0/loss.png b/fn_gen/nlr_t_no_sched/0/loss.png
new file mode 100644
index 0000000000000000000000000000000000000000..f56071b4690884c7156812bf46aafbba0e50ef90
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/0/loss.png differ
diff --git a/fn_gen/nlr_t_no_sched/0/quantization.png b/fn_gen/nlr_t_no_sched/0/quantization.png
new file mode 100644
index 0000000000000000000000000000000000000000..603c357d788657833e7f474abf105eaba01d2bdb
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/0/quantization.png differ
diff --git a/fn_gen/nlr_t_no_sched/1/distortion.png b/fn_gen/nlr_t_no_sched/1/distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..9eec6cc4d58fd620f02e7729fd4c21949b496fef
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/1/distortion.png differ
diff --git a/fn_gen/nlr_t_no_sched/1/expressions.txt b/fn_gen/nlr_t_no_sched/1/expressions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e8458af52eb4cfce21cf8459f3c454003cd78158
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/1/expressions.txt
@@ -0,0 +1,2 @@
+sqrt(_0*x)/_s
+_s**2*x**2/_0
\ No newline at end of file
diff --git a/fn_gen/nlr_t_no_sched/1/fn.py b/fn_gen/nlr_t_no_sched/1/fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a38249b0714be4db225c3c6317ee4a3ccdc435f
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/1/fn.py
@@ -0,0 +1,479 @@
+from __future__ import annotations
+
+import torch
+from torch import amin  # Necessary for arcsin
+import copy
+import torch.nn as nn
+import numpy as np
+
+from scipy.optimize import curve_fit
+from typing import Dict, Any, Tuple, List, Callable
+
+
+def quantization(x, **params):
+	return (torch.div(1, replace_num(params['_s'], num=0, to=10000)) * torch.sqrt(domain_guard((params['_0'] * x), min=0.1, nan=0.1)))
+
+
+def dequantization(x, **params):
+	return (torch.div(1, replace_num(params['_0'], num=0, to=10000)) * guarded_torch_power(params['_s'], torch.tensor(2)) * guarded_torch_power(x, torch.tensor(2)))
+
+
+def init_params(x: torch.Tensor, **kwargs: Dict[str, Any]) -> Dict[str, nn.Parameter]:
+	base_p0 = {
+	'_0': init_space_search(x, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], param='_0', **kwargs),
+	}
+
+	base_p0['_s'] = init_linear_scale(x, qtz_func=quantization, params=base_p0, **kwargs)
+	if 'post_init_hook' in kwargs:
+		kwargs['post_init_hook'](parameters=base_p0)
+	
+	params = init_non_linear_regression_fit(x, p0=base_p0, np_fit_func=fit_func, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], **kwargs)
+	params = {k: nn.Parameter(v, requires_grad=False) for k, v in params.items()}
+	if 'post_method_hook' in kwargs:
+		kwargs['post_method_hook'](parameters=params)
+	
+	params = learn_parameters(x, params,
+		qtz_func=quantization,
+		deqtz_func=dequantization,
+		bits=kwargs['bits'],
+		target_dtype=torch.int8,
+		epochs=500,
+		early_stop=False,
+	)
+	if 'post_train_hook' in kwargs:
+		kwargs['post_train_hook'](parameters=params)
+	
+	return params
+
+
+############### Numpy Qtz ###############
+
+
+def np_quantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_s, num=0, to=10000)) * np.sqrt(np_domain_guard((_0 * x), min=0.1, nan=0.1)))
+
+
+def np_dequantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_0, num=0, to=10000)) * np_guarded_power(_s, np.array(2)) * np_guarded_power(x, np.array(2)))
+
+
+def fit_func(x, _0, _s):
+    x_ = np_quantization(x, _0, _s)
+    x_ = np_dequantization(x_, _0, _s)
+    return x_
+
+
+
+############### HELPERS ###############
+
+def domain_guard(
+        x: torch.Tensor, 
+        min: float = None, 
+        max: float = None, 
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> torch.Tensor:
+    """Guard a tensor to a valid domain."""
+    x = torch.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = torch.clamp(x, min=min, max=max)
+    return x
+
+
+def replace_num(x: torch.Tensor, num: float, to: float) -> torch.Tensor:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (torch.Tensor): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        torch.Tensor: The tensor with the number replaced.
+    """
+    return torch.where(x == num, to, x)
+
+
+def guarded_torch_power(x: torch.Tensor, exp: float) -> torch.Tensor:
+    """Guard the power operation to a valid domain."""
+    return torch.pow(x, exp) if exp >= 1 else torch.pow(torch.relu(x), exp)
+
+
+def init_ones(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.ones_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_rand(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.randn_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_space_search(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    def _build_initial_param(tensor: torch.Tensor, max_initial: int, n_params: int):
+        """Generates the initial set of parameters. The first iteration generates 10 times more parameters."""
+        for _ in range(n_params * 10):  # The first iteration generates 10 times more parameters
+            yield init_rand(tensor) * max_initial  # Generates n_params in range [-max_initial, max_initial]
+
+    def _search_param(tensors: List[torch.tensor], n_params):
+        """Takes the best parameters and generates new parameters around the mean of the best parameters."""
+        torch_tensors = torch.stack(tensors)
+        min_vals, max_vals = torch.aminmax(torch_tensors, dim=0)
+        abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+        mean = torch.mean(torch_tensors, dim=0)
+        for _ in range(n_params):  # Generates n_params around the mean of the tensors
+            yield torch.randn_like(min_vals) * abs_max_val_per_ch + mean
+
+    def _calc(x, qtz_func, deqtz_func, **params):
+        x_ = x.transpose(0, 1)
+        x_ = qtz_func(x=x_, **params)
+        x_ = deqtz_func(x=x_, **params)
+        x_ = x_.transpose(0, 1)
+        return x_
+
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+    assert "deqtz_func" in kwargs, "deqtz_func must be provided."
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "param" in kwargs, "param must be provided."
+
+    qtz_func = kwargs.get('qtz_func')
+    deqtz_func = kwargs.get('deqtz_func')
+    params_list = kwargs.get('params_list')
+    param = kwargs.get('param')
+
+    n_runs = 50                # Number of runs to try to find the best parameters
+    n_random_params = 50       # Number of random parameters to generate
+    n_best_to_pick = 5         # Number of best parameters to pick after each run
+    max_initial = 10000        # Maximum value to initialize the parameters
+
+    # Initializes the parameters
+    base_params = { p: init_ones(x, **kwargs) for p in params_list if p != param }
+    params = _build_initial_param(x, max_initial, n_random_params)
+
+    # Performs the search
+    for _ in range(n_runs):
+        
+        best_params = []
+        for param_ in params:
+            try:
+                x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: param_})
+                loss_ones = nn.MSELoss()(x, x_)
+
+                if len(best_params) < n_best_to_pick:
+                    best_params.append((param_, loss_ones.item()))
+                    best_params = sorted(best_params, key=lambda x: x[1])
+                elif loss_ones < best_params[-1][1]:
+                    best_params[-1] = (param_, loss_ones.item())
+                    best_params = sorted(best_params, key=lambda x: x[1])
+
+            except Exception:  # The parameters might not be valid for the function's domain
+                continue
+
+        # Generates new parameters around the mean
+        params = _search_param([p for p, _ in best_params], n_random_params)
+
+    # Checks if the best parameter is better than the init_ones
+    p_ones = init_ones(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_ones})
+    loss_ones = nn.MSELoss()(x, x_)
+
+    # Checks if the best parameter is better than the init_rand
+    p_rand = init_rand(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_rand})
+    loss_rand = nn.MSELoss()(x, x_)
+
+    if loss_rand < best_params[0][1] and loss_rand < loss_ones:
+        return p_rand
+    elif loss_ones < best_params[0][1] and loss_ones < loss_rand:
+        return p_ones
+    else:
+        return best_params[0][0]
+
+
+def init_linear_scale(  # Symmetric scale. From the study folder
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+    assert "bits" in kwargs, "bits must be provided."
+    assert "params" in kwargs, "params must be provided."
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+
+    bits = kwargs.get('bits')
+    params = kwargs.get('params')
+    qtz_func = kwargs.get('qtz_func')
+
+    x_ = x.transpose(0, 1)
+    x_ = qtz_func(x=x_, **params, _s=init_ones(x, **kwargs))
+    x_ = x_.transpose(0, 1)
+    
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    min_vals, max_vals = torch.aminmax(x_, dim=1)
+    min_vals = torch.min(min_vals, torch.zeros_like(min_vals))
+    max_vals = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    eps = torch.finfo(torch.float32).eps
+
+    abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+    scale = abs_max_val_per_ch / (float(quant_max - quant_min) / 2)
+    
+    scale = torch.clamp(scale, min=eps).to(dtype=torch.float32, device=min_vals.device)
+
+    # Introduces some noise in scale
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything.
+    # NOTE(diogo): This has been disproven. The noise does not help the learning process but I still
+    # left it here for future reference. Will be removed later.
+    # scale = scale + 0.01 * torch.randn_like(scale)
+
+    return scale
+
+
+def init_non_linear_regression_fit(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "np_fit_func" in kwargs, "np_fit_func must be provided."
+    assert "p0" in kwargs, "p0 must be provided."
+    np_fit_func = kwargs.get('np_fit_func')
+    params_list = kwargs.get('params_list')
+    p0 = kwargs.get('p0')
+
+    def _fit(xdata: np.ndarray, ydata: np.ndarray, func: Callable, p0: List[float]):
+        popt, _ = curve_fit(
+            func, 
+            xdata, 
+            ydata, 
+            maxfev=1000,
+            p0=p0,
+            method='lm'
+        )
+        return popt
+
+    # 1. Needs to convert the torch tensor to numpy tensor
+    xdata = x.cpu().numpy()
+
+    # 2. Sorts the data so that it makes it easier to fit to it
+    sorted_xdata = np.sort(xdata, axis=-1)
+
+    p0 = {k: v.cpu().numpy() for k, v in p0.items()}
+    params_list = sorted(params_list)  # We need to make sure that it matches the numpy fit func arg order
+
+    # 3. Finds the best parameters for each channel
+    try:
+        params = []
+        for i in range(sorted_xdata.shape[0]):
+            xdata_ = sorted_xdata[i]
+            p0_ = [p0[p][i] for p in params_list]
+            ch_params = _fit(xdata_, xdata_, np_fit_func, p0_)
+            params.append(ch_params)
+
+        # 4. Builds the parameters
+        result = {}
+        for i, p in enumerate(params_list):
+            result[p] = torch.tensor([p_[i] for p_ in params], dtype=torch.float32).to(x.device)
+
+        return result
+
+    except ValueError as e:
+        print(f"Could not fit the function with error: {e}")
+        print(f"Using fallback result...")
+        return {
+            k: torch.tensor(v, dtype=torch.float32).to(x.device) for k, v in p0.items()
+        }
+
+
+def init_zeros(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.zeros_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_inner_scale(tensor: torch.Tensor, _min: float = torch.inf, _max: float = torch.inf) -> torch.Tensor:
+    # Calculate the original minimum and maximum values
+    min_vals, max_vals = torch.aminmax(tensor, dim=-1)
+    x_min = torch.min(min_vals, torch.zeros_like(min_vals))
+    x_max = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    if _max is torch.inf:  # We do not need to scale the tensor. Just need to move it
+        return torch.ones_like(x_min)
+    
+    # Calculate the scale factor
+    scale = (_max - _min) / (x_max - x_min)
+    return scale
+
+
+
+############## Quant ###############
+
+@torch.enable_grad()
+def learn_parameters(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    qtz_func: nn.Module,
+    deqtz_func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype,
+    epochs: int = 1000,
+    early_stop: bool = True,
+    do_report: bool = False
+) -> Tuple[Dict[str, nn.Parameter], torch.Tensor]:
+    loss_fn = nn.MSELoss()
+
+    # Determines the initial learning rate by computing the initial loss and multiplying it by
+    # the order of magnitude of the loss divided by 2
+    quant = quantize(x, params, qtz_func, bits, target_dtype)
+    dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+    loss = loss_fn(x, dequant)
+
+    base_lr = 0.1
+    exponent = int(np.floor(np.log10(loss.item())))
+    lr = base_lr * (10 ** (exponent // 2))
+    
+    # Requires gradients in the parameters
+    for p in params.values():
+        p.requires_grad = True
+        p.grad = None
+
+    param_keys = list(params.keys())
+    param_values = list(params.values())
+
+    # Defines optimizer and loss function
+    optimizer = torch.optim.Adam(param_values, lr=lr)
+
+    # Contains the best loss and the best parameters 
+    best_loss = float("inf")
+    best_params = None
+
+    # Used to stop the search early
+    min_delta = 1e-7
+    acc_loss = []
+    percent_epochs_before_stop = 0.1
+
+    for i in range(epochs):
+        optimizer.zero_grad()
+
+        quant = quantize(x, params, qtz_func, bits, target_dtype)
+        dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+        loss = loss_fn(x, dequant)
+
+        if loss.isnan() or loss.isinf():
+            raise Exception("Loss is NaN or Inf. Stopping the search.")
+
+        loss.backward()
+        optimizer.step()
+
+        acc_loss.append(loss.item())
+
+        # Reports loss every 10 steps
+        if i % 10 == 0 and do_report:
+            print(f"Epoch {i}: Loss {loss.item()}")
+
+        # Optimizes the parameter search by storing the best loss and the parameters
+        if loss.item() < best_loss:
+            best_loss = loss.item()
+            best_params = copy.deepcopy({
+                k: v for k, v in params.items() if k in param_keys
+            })
+
+        # We also stop the search if the loss has not considerably during the last 10% epochs
+        if early_stop:
+            epochs_before_stop = int(epochs * percent_epochs_before_stop)
+            if i > epochs_before_stop and abs(acc_loss[i - epochs_before_stop] - acc_loss[i]) < min_delta:
+                break
+
+    # No longer requires gradients in the parameters
+    for p in best_params.values():
+        p.requires_grad = False
+        p.grad = None
+    
+    if do_report:
+        print(f"Best loss: {best_loss}")
+        return best_params, acc_loss
+    else:
+        return best_params
+
+
+def quantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype = torch.int8
+) -> torch.Tensor:
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    x = x.transpose(0, 1)  # Aligns shapes
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    x = torch.clamp(round_func_BPDA(x), quant_min, quant_max).to(target_dtype)
+    return x
+
+
+def dequantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    out_dtype: torch.dtype
+) -> torch.Tensor:
+    x = x.to(dtype=out_dtype)
+    x = x.transpose(0, 1)
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    return x
+
+
+def round_func_BPDA(input):
+    # This is equivalent to replacing round function (non-differentiable) with
+    # an identity function (differentiable) only when backward.
+    forward_value = torch.round(input)
+    out = input.clone()
+    out.data = forward_value.data
+    return out
+
+
+def get_min_max_from_bits_signed(bit_width: int) -> Tuple[int, int]:
+    return -2 ** (bit_width - 1), 2 ** (bit_width - 1) - 1
+
+
+
+############## Numpy ###############
+
+def np_domain_guard(
+        x: np.ndarray,
+        min: float = None,
+        max: float = None,
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> np.ndarray:
+    """Guard a tensor to a valid domain."""
+    x = np.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = np.clip(x, min, max)
+    return x
+
+
+def np_replace_num(x: np.ndarray, num: float, to: float) -> np.ndarray:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (np.ndarray): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        np.ndarray: The tensor with the number replaced.
+    """
+    return np.where(x == num, to, x)
+
+
+def np_guarded_power(x: np.ndarray, exp: float) -> np.ndarray:
+    """Guard the power operation to a valid domain."""
+    return np.power(x, exp) if exp >= 1 else np.power(np.maximum(x, 0), exp)
+
diff --git a/fn_gen/nlr_t_no_sched/1/loss.png b/fn_gen/nlr_t_no_sched/1/loss.png
new file mode 100644
index 0000000000000000000000000000000000000000..2c0205c66fd723daf330fc53daadea24e4689d48
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/1/loss.png differ
diff --git a/fn_gen/nlr_t_no_sched/1/quantization.png b/fn_gen/nlr_t_no_sched/1/quantization.png
new file mode 100644
index 0000000000000000000000000000000000000000..4e95193d12e7fd6fc5e735288e9f6eb55008289b
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/1/quantization.png differ
diff --git a/fn_gen/nlr_t_no_sched/10/distortion.png b/fn_gen/nlr_t_no_sched/10/distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..61e77f52b163a1ecdf7a4398bcd0d3fd6bb6d955
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/10/distortion.png differ
diff --git a/fn_gen/nlr_t_no_sched/10/expressions.txt b/fn_gen/nlr_t_no_sched/10/expressions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9aa25379a9d1d5a93d60659c6609b2e24e79234d
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/10/expressions.txt
@@ -0,0 +1,2 @@
+exp(_0*x)/_s
+log(_s*x)/_0
\ No newline at end of file
diff --git a/fn_gen/nlr_t_no_sched/10/fn.py b/fn_gen/nlr_t_no_sched/10/fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..710eda8585734d23cf888ff73b2d5633931db80c
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/10/fn.py
@@ -0,0 +1,479 @@
+from __future__ import annotations
+
+import torch
+from torch import amin  # Necessary for arcsin
+import copy
+import torch.nn as nn
+import numpy as np
+
+from scipy.optimize import curve_fit
+from typing import Dict, Any, Tuple, List, Callable
+
+
+def quantization(x, **params):
+	return (torch.div(1, replace_num(params['_s'], num=0, to=10000)) * torch.exp((params['_0'] * x)))
+
+
+def dequantization(x, **params):
+	return (torch.div(1, replace_num(params['_0'], num=0, to=10000)) * torch.log(domain_guard((params['_s'] * x), min=1e-5, nan=1e-5)))
+
+
+def init_params(x: torch.Tensor, **kwargs: Dict[str, Any]) -> Dict[str, nn.Parameter]:
+	base_p0 = {
+	'_0': init_space_search(x, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], param='_0', **kwargs),
+	}
+
+	base_p0['_s'] = init_linear_scale(x, qtz_func=quantization, params=base_p0, **kwargs)
+	if 'post_init_hook' in kwargs:
+		kwargs['post_init_hook'](parameters=base_p0)
+	
+	params = init_non_linear_regression_fit(x, p0=base_p0, np_fit_func=fit_func, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], **kwargs)
+	params = {k: nn.Parameter(v, requires_grad=False) for k, v in params.items()}
+	if 'post_method_hook' in kwargs:
+		kwargs['post_method_hook'](parameters=params)
+	
+	params = learn_parameters(x, params,
+		qtz_func=quantization,
+		deqtz_func=dequantization,
+		bits=kwargs['bits'],
+		target_dtype=torch.int8,
+		epochs=500,
+		early_stop=False,
+	)
+	if 'post_train_hook' in kwargs:
+		kwargs['post_train_hook'](parameters=params)
+	
+	return params
+
+
+############### Numpy Qtz ###############
+
+
+def np_quantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_s, num=0, to=10000)) * np.exp((_0 * x)))
+
+
+def np_dequantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_0, num=0, to=10000)) * np.log(np_domain_guard((_s * x), min=1e-5, nan=1e-5)))
+
+
+def fit_func(x, _0, _s):
+    x_ = np_quantization(x, _0, _s)
+    x_ = np_dequantization(x_, _0, _s)
+    return x_
+
+
+
+############### HELPERS ###############
+
+def domain_guard(
+        x: torch.Tensor, 
+        min: float = None, 
+        max: float = None, 
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> torch.Tensor:
+    """Guard a tensor to a valid domain."""
+    x = torch.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = torch.clamp(x, min=min, max=max)
+    return x
+
+
+def replace_num(x: torch.Tensor, num: float, to: float) -> torch.Tensor:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (torch.Tensor): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        torch.Tensor: The tensor with the number replaced.
+    """
+    return torch.where(x == num, to, x)
+
+
+def guarded_torch_power(x: torch.Tensor, exp: float) -> torch.Tensor:
+    """Guard the power operation to a valid domain."""
+    return torch.pow(x, exp) if exp >= 1 else torch.pow(torch.relu(x), exp)
+
+
+def init_ones(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.ones_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_rand(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.randn_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_space_search(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    def _build_initial_param(tensor: torch.Tensor, max_initial: int, n_params: int):
+        """Generates the initial set of parameters. The first iteration generates 10 times more parameters."""
+        for _ in range(n_params * 10):  # The first iteration generates 10 times more parameters
+            yield init_rand(tensor) * max_initial  # Generates n_params in range [-max_initial, max_initial]
+
+    def _search_param(tensors: List[torch.tensor], n_params):
+        """Takes the best parameters and generates new parameters around the mean of the best parameters."""
+        torch_tensors = torch.stack(tensors)
+        min_vals, max_vals = torch.aminmax(torch_tensors, dim=0)
+        abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+        mean = torch.mean(torch_tensors, dim=0)
+        for _ in range(n_params):  # Generates n_params around the mean of the tensors
+            yield torch.randn_like(min_vals) * abs_max_val_per_ch + mean
+
+    def _calc(x, qtz_func, deqtz_func, **params):
+        x_ = x.transpose(0, 1)
+        x_ = qtz_func(x=x_, **params)
+        x_ = deqtz_func(x=x_, **params)
+        x_ = x_.transpose(0, 1)
+        return x_
+
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+    assert "deqtz_func" in kwargs, "deqtz_func must be provided."
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "param" in kwargs, "param must be provided."
+
+    qtz_func = kwargs.get('qtz_func')
+    deqtz_func = kwargs.get('deqtz_func')
+    params_list = kwargs.get('params_list')
+    param = kwargs.get('param')
+
+    n_runs = 50                # Number of runs to try to find the best parameters
+    n_random_params = 50       # Number of random parameters to generate
+    n_best_to_pick = 5         # Number of best parameters to pick after each run
+    max_initial = 10000        # Maximum value to initialize the parameters
+
+    # Initializes the parameters
+    base_params = { p: init_ones(x, **kwargs) for p in params_list if p != param }
+    params = _build_initial_param(x, max_initial, n_random_params)
+
+    # Performs the search
+    for _ in range(n_runs):
+        
+        best_params = []
+        for param_ in params:
+            try:
+                x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: param_})
+                loss_ones = nn.MSELoss()(x, x_)
+
+                if len(best_params) < n_best_to_pick:
+                    best_params.append((param_, loss_ones.item()))
+                    best_params = sorted(best_params, key=lambda x: x[1])
+                elif loss_ones < best_params[-1][1]:
+                    best_params[-1] = (param_, loss_ones.item())
+                    best_params = sorted(best_params, key=lambda x: x[1])
+
+            except Exception:  # The parameters might not be valid for the function's domain
+                continue
+
+        # Generates new parameters around the mean
+        params = _search_param([p for p, _ in best_params], n_random_params)
+
+    # Checks if the best parameter is better than the init_ones
+    p_ones = init_ones(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_ones})
+    loss_ones = nn.MSELoss()(x, x_)
+
+    # Checks if the best parameter is better than the init_rand
+    p_rand = init_rand(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_rand})
+    loss_rand = nn.MSELoss()(x, x_)
+
+    if loss_rand < best_params[0][1] and loss_rand < loss_ones:
+        return p_rand
+    elif loss_ones < best_params[0][1] and loss_ones < loss_rand:
+        return p_ones
+    else:
+        return best_params[0][0]
+
+
+def init_linear_scale(  # Symmetric scale. From the study folder
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+    assert "bits" in kwargs, "bits must be provided."
+    assert "params" in kwargs, "params must be provided."
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+
+    bits = kwargs.get('bits')
+    params = kwargs.get('params')
+    qtz_func = kwargs.get('qtz_func')
+
+    x_ = x.transpose(0, 1)
+    x_ = qtz_func(x=x_, **params, _s=init_ones(x, **kwargs))
+    x_ = x_.transpose(0, 1)
+    
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    min_vals, max_vals = torch.aminmax(x_, dim=1)
+    min_vals = torch.min(min_vals, torch.zeros_like(min_vals))
+    max_vals = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    eps = torch.finfo(torch.float32).eps
+
+    abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+    scale = abs_max_val_per_ch / (float(quant_max - quant_min) / 2)
+    
+    scale = torch.clamp(scale, min=eps).to(dtype=torch.float32, device=min_vals.device)
+
+    # Introduces some noise in scale
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything.
+    # NOTE(diogo): This has been disproven. The noise does not help the learning process but I still
+    # left it here for future reference. Will be removed later.
+    # scale = scale + 0.01 * torch.randn_like(scale)
+
+    return scale
+
+
+def init_non_linear_regression_fit(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "np_fit_func" in kwargs, "np_fit_func must be provided."
+    assert "p0" in kwargs, "p0 must be provided."
+    np_fit_func = kwargs.get('np_fit_func')
+    params_list = kwargs.get('params_list')
+    p0 = kwargs.get('p0')
+
+    def _fit(xdata: np.ndarray, ydata: np.ndarray, func: Callable, p0: List[float]):
+        popt, _ = curve_fit(
+            func, 
+            xdata, 
+            ydata, 
+            maxfev=1000,
+            p0=p0,
+            method='lm'
+        )
+        return popt
+
+    # 1. Needs to convert the torch tensor to numpy tensor
+    xdata = x.cpu().numpy()
+
+    # 2. Sorts the data so that it makes it easier to fit to it
+    sorted_xdata = np.sort(xdata, axis=-1)
+
+    p0 = {k: v.cpu().numpy() for k, v in p0.items()}
+    params_list = sorted(params_list)  # We need to make sure that it matches the numpy fit func arg order
+
+    # 3. Finds the best parameters for each channel
+    try:
+        params = []
+        for i in range(sorted_xdata.shape[0]):
+            xdata_ = sorted_xdata[i]
+            p0_ = [p0[p][i] for p in params_list]
+            ch_params = _fit(xdata_, xdata_, np_fit_func, p0_)
+            params.append(ch_params)
+
+        # 4. Builds the parameters
+        result = {}
+        for i, p in enumerate(params_list):
+            result[p] = torch.tensor([p_[i] for p_ in params], dtype=torch.float32).to(x.device)
+
+        return result
+
+    except ValueError as e:
+        print(f"Could not fit the function with error: {e}")
+        print(f"Using fallback result...")
+        return {
+            k: torch.tensor(v, dtype=torch.float32).to(x.device) for k, v in p0.items()
+        }
+
+
+def init_zeros(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.zeros_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_inner_scale(tensor: torch.Tensor, _min: float = torch.inf, _max: float = torch.inf) -> torch.Tensor:
+    # Calculate the original minimum and maximum values
+    min_vals, max_vals = torch.aminmax(tensor, dim=-1)
+    x_min = torch.min(min_vals, torch.zeros_like(min_vals))
+    x_max = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    if _max is torch.inf:  # We do not need to scale the tensor. Just need to move it
+        return torch.ones_like(x_min)
+    
+    # Calculate the scale factor
+    scale = (_max - _min) / (x_max - x_min)
+    return scale
+
+
+
+############## Quant ###############
+
+@torch.enable_grad()
+def learn_parameters(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    qtz_func: nn.Module,
+    deqtz_func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype,
+    epochs: int = 1000,
+    early_stop: bool = True,
+    do_report: bool = False
+) -> Tuple[Dict[str, nn.Parameter], torch.Tensor]:
+    loss_fn = nn.MSELoss()
+
+    # Determines the initial learning rate by computing the initial loss and multiplying it by
+    # the order of magnitude of the loss divided by 2
+    quant = quantize(x, params, qtz_func, bits, target_dtype)
+    dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+    loss = loss_fn(x, dequant)
+
+    base_lr = 0.1
+    exponent = int(np.floor(np.log10(loss.item())))
+    lr = base_lr * (10 ** (exponent // 2))
+    
+    # Requires gradients in the parameters
+    for p in params.values():
+        p.requires_grad = True
+        p.grad = None
+
+    param_keys = list(params.keys())
+    param_values = list(params.values())
+
+    # Defines optimizer and loss function
+    optimizer = torch.optim.Adam(param_values, lr=lr)
+
+    # Contains the best loss and the best parameters 
+    best_loss = float("inf")
+    best_params = None
+
+    # Used to stop the search early
+    min_delta = 1e-7
+    acc_loss = []
+    percent_epochs_before_stop = 0.1
+
+    for i in range(epochs):
+        optimizer.zero_grad()
+
+        quant = quantize(x, params, qtz_func, bits, target_dtype)
+        dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+        loss = loss_fn(x, dequant)
+
+        if loss.isnan() or loss.isinf():
+            raise Exception("Loss is NaN or Inf. Stopping the search.")
+
+        loss.backward()
+        optimizer.step()
+
+        acc_loss.append(loss.item())
+
+        # Reports loss every 10 steps
+        if i % 10 == 0 and do_report:
+            print(f"Epoch {i}: Loss {loss.item()}")
+
+        # Optimizes the parameter search by storing the best loss and the parameters
+        if loss.item() < best_loss:
+            best_loss = loss.item()
+            best_params = copy.deepcopy({
+                k: v for k, v in params.items() if k in param_keys
+            })
+
+        # We also stop the search if the loss has not considerably during the last 10% epochs
+        if early_stop:
+            epochs_before_stop = int(epochs * percent_epochs_before_stop)
+            if i > epochs_before_stop and abs(acc_loss[i - epochs_before_stop] - acc_loss[i]) < min_delta:
+                break
+
+    # No longer requires gradients in the parameters
+    for p in best_params.values():
+        p.requires_grad = False
+        p.grad = None
+    
+    if do_report:
+        print(f"Best loss: {best_loss}")
+        return best_params, acc_loss
+    else:
+        return best_params
+
+
+def quantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype = torch.int8
+) -> torch.Tensor:
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    x = x.transpose(0, 1)  # Aligns shapes
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    x = torch.clamp(round_func_BPDA(x), quant_min, quant_max).to(target_dtype)
+    return x
+
+
+def dequantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    out_dtype: torch.dtype
+) -> torch.Tensor:
+    x = x.to(dtype=out_dtype)
+    x = x.transpose(0, 1)
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    return x
+
+
+def round_func_BPDA(input):
+    # This is equivalent to replacing round function (non-differentiable) with
+    # an identity function (differentiable) only when backward.
+    forward_value = torch.round(input)
+    out = input.clone()
+    out.data = forward_value.data
+    return out
+
+
+def get_min_max_from_bits_signed(bit_width: int) -> Tuple[int, int]:
+    return -2 ** (bit_width - 1), 2 ** (bit_width - 1) - 1
+
+
+
+############## Numpy ###############
+
+def np_domain_guard(
+        x: np.ndarray,
+        min: float = None,
+        max: float = None,
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> np.ndarray:
+    """Guard a tensor to a valid domain."""
+    x = np.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = np.clip(x, min, max)
+    return x
+
+
+def np_replace_num(x: np.ndarray, num: float, to: float) -> np.ndarray:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (np.ndarray): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        np.ndarray: The tensor with the number replaced.
+    """
+    return np.where(x == num, to, x)
+
+
+def np_guarded_power(x: np.ndarray, exp: float) -> np.ndarray:
+    """Guard the power operation to a valid domain."""
+    return np.power(x, exp) if exp >= 1 else np.power(np.maximum(x, 0), exp)
+
diff --git a/fn_gen/nlr_t_no_sched/10/loss.png b/fn_gen/nlr_t_no_sched/10/loss.png
new file mode 100644
index 0000000000000000000000000000000000000000..799417341d3c6e2dabb15d38d4d45b93e0aee965
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/10/loss.png differ
diff --git a/fn_gen/nlr_t_no_sched/10/quantization.png b/fn_gen/nlr_t_no_sched/10/quantization.png
new file mode 100644
index 0000000000000000000000000000000000000000..8f613eaf91ab9633127c58917c21d20d8a058951
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/10/quantization.png differ
diff --git a/fn_gen/nlr_t_no_sched/11/distortion.png b/fn_gen/nlr_t_no_sched/11/distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..a2ee371b1e8485c42a4c71d82570d92f84b5ccd0
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/11/distortion.png differ
diff --git a/fn_gen/nlr_t_no_sched/11/expressions.txt b/fn_gen/nlr_t_no_sched/11/expressions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dbb6da0fc54c6f23dc12daf2e2c3a395819e1bf4
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/11/expressions.txt
@@ -0,0 +1,2 @@
+x**2/_s
+sqrt(_s*x)
\ No newline at end of file
diff --git a/fn_gen/nlr_t_no_sched/11/fn.py b/fn_gen/nlr_t_no_sched/11/fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..09b051cc40f5b5f0cdad4cc218acb2cd119ea099
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/11/fn.py
@@ -0,0 +1,478 @@
+from __future__ import annotations
+
+import torch
+from torch import amin  # Necessary for arcsin
+import copy
+import torch.nn as nn
+import numpy as np
+
+from scipy.optimize import curve_fit
+from typing import Dict, Any, Tuple, List, Callable
+
+
+def quantization(x, **params):
+	return (torch.div(1, replace_num(params['_s'], num=0, to=10000)) * guarded_torch_power(x, torch.tensor(2)))
+
+
+def dequantization(x, **params):
+	return torch.sqrt(domain_guard((params['_s'] * x), min=0.1, nan=0.1))
+
+
+def init_params(x: torch.Tensor, **kwargs: Dict[str, Any]) -> Dict[str, nn.Parameter]:
+	base_p0 = {
+	}
+
+	base_p0['_s'] = init_linear_scale(x, qtz_func=quantization, params=base_p0, **kwargs)
+	if 'post_init_hook' in kwargs:
+		kwargs['post_init_hook'](parameters=base_p0)
+	
+	params = init_non_linear_regression_fit(x, p0=base_p0, np_fit_func=fit_func, qtz_func=quantization, deqtz_func=dequantization, params_list=['_s'], **kwargs)
+	params = {k: nn.Parameter(v, requires_grad=False) for k, v in params.items()}
+	if 'post_method_hook' in kwargs:
+		kwargs['post_method_hook'](parameters=params)
+	
+	params = learn_parameters(x, params,
+		qtz_func=quantization,
+		deqtz_func=dequantization,
+		bits=kwargs['bits'],
+		target_dtype=torch.int8,
+		epochs=500,
+		early_stop=False,
+	)
+	if 'post_train_hook' in kwargs:
+		kwargs['post_train_hook'](parameters=params)
+	
+	return params
+
+
+############### Numpy Qtz ###############
+
+
+def np_quantization(x, _s):
+	return (np.divide(1, np_replace_num(_s, num=0, to=10000)) * np_guarded_power(x, np.array(2)))
+
+
+def np_dequantization(x, _s):
+	return np.sqrt(np_domain_guard((_s * x), min=0.1, nan=0.1))
+
+
+def fit_func(x, _s):
+    x_ = np_quantization(x, _s)
+    x_ = np_dequantization(x_, _s)
+    return x_
+
+
+
+############### HELPERS ###############
+
+def domain_guard(
+        x: torch.Tensor, 
+        min: float = None, 
+        max: float = None, 
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> torch.Tensor:
+    """Guard a tensor to a valid domain."""
+    x = torch.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = torch.clamp(x, min=min, max=max)
+    return x
+
+
+def replace_num(x: torch.Tensor, num: float, to: float) -> torch.Tensor:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (torch.Tensor): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        torch.Tensor: The tensor with the number replaced.
+    """
+    return torch.where(x == num, to, x)
+
+
+def guarded_torch_power(x: torch.Tensor, exp: float) -> torch.Tensor:
+    """Guard the power operation to a valid domain."""
+    return torch.pow(x, exp) if exp >= 1 else torch.pow(torch.relu(x), exp)
+
+
+def init_ones(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.ones_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_rand(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.randn_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_space_search(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    def _build_initial_param(tensor: torch.Tensor, max_initial: int, n_params: int):
+        """Generates the initial set of parameters. The first iteration generates 10 times more parameters."""
+        for _ in range(n_params * 10):  # The first iteration generates 10 times more parameters
+            yield init_rand(tensor) * max_initial  # Generates n_params in range [-max_initial, max_initial]
+
+    def _search_param(tensors: List[torch.tensor], n_params):
+        """Takes the best parameters and generates new parameters around the mean of the best parameters."""
+        torch_tensors = torch.stack(tensors)
+        min_vals, max_vals = torch.aminmax(torch_tensors, dim=0)
+        abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+        mean = torch.mean(torch_tensors, dim=0)
+        for _ in range(n_params):  # Generates n_params around the mean of the tensors
+            yield torch.randn_like(min_vals) * abs_max_val_per_ch + mean
+
+    def _calc(x, qtz_func, deqtz_func, **params):
+        x_ = x.transpose(0, 1)
+        x_ = qtz_func(x=x_, **params)
+        x_ = deqtz_func(x=x_, **params)
+        x_ = x_.transpose(0, 1)
+        return x_
+
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+    assert "deqtz_func" in kwargs, "deqtz_func must be provided."
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "param" in kwargs, "param must be provided."
+
+    qtz_func = kwargs.get('qtz_func')
+    deqtz_func = kwargs.get('deqtz_func')
+    params_list = kwargs.get('params_list')
+    param = kwargs.get('param')
+
+    n_runs = 50                # Number of runs to try to find the best parameters
+    n_random_params = 50       # Number of random parameters to generate
+    n_best_to_pick = 5         # Number of best parameters to pick after each run
+    max_initial = 10000        # Maximum value to initialize the parameters
+
+    # Initializes the parameters
+    base_params = { p: init_ones(x, **kwargs) for p in params_list if p != param }
+    params = _build_initial_param(x, max_initial, n_random_params)
+
+    # Performs the search
+    for _ in range(n_runs):
+        
+        best_params = []
+        for param_ in params:
+            try:
+                x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: param_})
+                loss_ones = nn.MSELoss()(x, x_)
+
+                if len(best_params) < n_best_to_pick:
+                    best_params.append((param_, loss_ones.item()))
+                    best_params = sorted(best_params, key=lambda x: x[1])
+                elif loss_ones < best_params[-1][1]:
+                    best_params[-1] = (param_, loss_ones.item())
+                    best_params = sorted(best_params, key=lambda x: x[1])
+
+            except Exception:  # The parameters might not be valid for the function's domain
+                continue
+
+        # Generates new parameters around the mean
+        params = _search_param([p for p, _ in best_params], n_random_params)
+
+    # Checks if the best parameter is better than the init_ones
+    p_ones = init_ones(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_ones})
+    loss_ones = nn.MSELoss()(x, x_)
+
+    # Checks if the best parameter is better than the init_rand
+    p_rand = init_rand(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_rand})
+    loss_rand = nn.MSELoss()(x, x_)
+
+    if loss_rand < best_params[0][1] and loss_rand < loss_ones:
+        return p_rand
+    elif loss_ones < best_params[0][1] and loss_ones < loss_rand:
+        return p_ones
+    else:
+        return best_params[0][0]
+
+
+def init_linear_scale(  # Symmetric scale. From the study folder
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+    assert "bits" in kwargs, "bits must be provided."
+    assert "params" in kwargs, "params must be provided."
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+
+    bits = kwargs.get('bits')
+    params = kwargs.get('params')
+    qtz_func = kwargs.get('qtz_func')
+
+    x_ = x.transpose(0, 1)
+    x_ = qtz_func(x=x_, **params, _s=init_ones(x, **kwargs))
+    x_ = x_.transpose(0, 1)
+    
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    min_vals, max_vals = torch.aminmax(x_, dim=1)
+    min_vals = torch.min(min_vals, torch.zeros_like(min_vals))
+    max_vals = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    eps = torch.finfo(torch.float32).eps
+
+    abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+    scale = abs_max_val_per_ch / (float(quant_max - quant_min) / 2)
+    
+    scale = torch.clamp(scale, min=eps).to(dtype=torch.float32, device=min_vals.device)
+
+    # Introduces some noise in scale
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything.
+    # NOTE(diogo): This has been disproven. The noise does not help the learning process but I still
+    # left it here for future reference. Will be removed later.
+    # scale = scale + 0.01 * torch.randn_like(scale)
+
+    return scale
+
+
+def init_non_linear_regression_fit(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "np_fit_func" in kwargs, "np_fit_func must be provided."
+    assert "p0" in kwargs, "p0 must be provided."
+    np_fit_func = kwargs.get('np_fit_func')
+    params_list = kwargs.get('params_list')
+    p0 = kwargs.get('p0')
+
+    def _fit(xdata: np.ndarray, ydata: np.ndarray, func: Callable, p0: List[float]):
+        popt, _ = curve_fit(
+            func, 
+            xdata, 
+            ydata, 
+            maxfev=1000,
+            p0=p0,
+            method='lm'
+        )
+        return popt
+
+    # 1. Needs to convert the torch tensor to numpy tensor
+    xdata = x.cpu().numpy()
+
+    # 2. Sorts the data so that it makes it easier to fit to it
+    sorted_xdata = np.sort(xdata, axis=-1)
+
+    p0 = {k: v.cpu().numpy() for k, v in p0.items()}
+    params_list = sorted(params_list)  # We need to make sure that it matches the numpy fit func arg order
+
+    # 3. Finds the best parameters for each channel
+    try:
+        params = []
+        for i in range(sorted_xdata.shape[0]):
+            xdata_ = sorted_xdata[i]
+            p0_ = [p0[p][i] for p in params_list]
+            ch_params = _fit(xdata_, xdata_, np_fit_func, p0_)
+            params.append(ch_params)
+
+        # 4. Builds the parameters
+        result = {}
+        for i, p in enumerate(params_list):
+            result[p] = torch.tensor([p_[i] for p_ in params], dtype=torch.float32).to(x.device)
+
+        return result
+
+    except ValueError as e:
+        print(f"Could not fit the function with error: {e}")
+        print(f"Using fallback result...")
+        return {
+            k: torch.tensor(v, dtype=torch.float32).to(x.device) for k, v in p0.items()
+        }
+
+
+def init_zeros(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.zeros_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_inner_scale(tensor: torch.Tensor, _min: float = torch.inf, _max: float = torch.inf) -> torch.Tensor:
+    # Calculate the original minimum and maximum values
+    min_vals, max_vals = torch.aminmax(tensor, dim=-1)
+    x_min = torch.min(min_vals, torch.zeros_like(min_vals))
+    x_max = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    if _max is torch.inf:  # We do not need to scale the tensor. Just need to move it
+        return torch.ones_like(x_min)
+    
+    # Calculate the scale factor
+    scale = (_max - _min) / (x_max - x_min)
+    return scale
+
+
+
+############## Quant ###############
+
+@torch.enable_grad()
+def learn_parameters(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    qtz_func: nn.Module,
+    deqtz_func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype,
+    epochs: int = 1000,
+    early_stop: bool = True,
+    do_report: bool = False
+) -> Tuple[Dict[str, nn.Parameter], torch.Tensor]:
+    loss_fn = nn.MSELoss()
+
+    # Determines the initial learning rate by computing the initial loss and multiplying it by
+    # the order of magnitude of the loss divided by 2
+    quant = quantize(x, params, qtz_func, bits, target_dtype)
+    dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+    loss = loss_fn(x, dequant)
+
+    base_lr = 0.1
+    exponent = int(np.floor(np.log10(loss.item())))
+    lr = base_lr * (10 ** (exponent // 2))
+    
+    # Requires gradients in the parameters
+    for p in params.values():
+        p.requires_grad = True
+        p.grad = None
+
+    param_keys = list(params.keys())
+    param_values = list(params.values())
+
+    # Defines optimizer and loss function
+    optimizer = torch.optim.Adam(param_values, lr=lr)
+
+    # Contains the best loss and the best parameters 
+    best_loss = float("inf")
+    best_params = None
+
+    # Used to stop the search early
+    min_delta = 1e-7
+    acc_loss = []
+    percent_epochs_before_stop = 0.1
+
+    for i in range(epochs):
+        optimizer.zero_grad()
+
+        quant = quantize(x, params, qtz_func, bits, target_dtype)
+        dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+        loss = loss_fn(x, dequant)
+
+        if loss.isnan() or loss.isinf():
+            raise Exception("Loss is NaN or Inf. Stopping the search.")
+
+        loss.backward()
+        optimizer.step()
+
+        acc_loss.append(loss.item())
+
+        # Reports loss every 10 steps
+        if i % 10 == 0 and do_report:
+            print(f"Epoch {i}: Loss {loss.item()}")
+
+        # Optimizes the parameter search by storing the best loss and the parameters
+        if loss.item() < best_loss:
+            best_loss = loss.item()
+            best_params = copy.deepcopy({
+                k: v for k, v in params.items() if k in param_keys
+            })
+
+        # We also stop the search if the loss has not considerably during the last 10% epochs
+        if early_stop:
+            epochs_before_stop = int(epochs * percent_epochs_before_stop)
+            if i > epochs_before_stop and abs(acc_loss[i - epochs_before_stop] - acc_loss[i]) < min_delta:
+                break
+
+    # No longer requires gradients in the parameters
+    for p in best_params.values():
+        p.requires_grad = False
+        p.grad = None
+    
+    if do_report:
+        print(f"Best loss: {best_loss}")
+        return best_params, acc_loss
+    else:
+        return best_params
+
+
+def quantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype = torch.int8
+) -> torch.Tensor:
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    x = x.transpose(0, 1)  # Aligns shapes
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    x = torch.clamp(round_func_BPDA(x), quant_min, quant_max).to(target_dtype)
+    return x
+
+
+def dequantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    out_dtype: torch.dtype
+) -> torch.Tensor:
+    x = x.to(dtype=out_dtype)
+    x = x.transpose(0, 1)
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    return x
+
+
+def round_func_BPDA(input):
+    # This is equivalent to replacing round function (non-differentiable) with
+    # an identity function (differentiable) only when backward.
+    forward_value = torch.round(input)
+    out = input.clone()
+    out.data = forward_value.data
+    return out
+
+
+def get_min_max_from_bits_signed(bit_width: int) -> Tuple[int, int]:
+    return -2 ** (bit_width - 1), 2 ** (bit_width - 1) - 1
+
+
+
+############## Numpy ###############
+
+def np_domain_guard(
+        x: np.ndarray,
+        min: float = None,
+        max: float = None,
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> np.ndarray:
+    """Guard a tensor to a valid domain."""
+    x = np.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = np.clip(x, min, max)
+    return x
+
+
+def np_replace_num(x: np.ndarray, num: float, to: float) -> np.ndarray:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (np.ndarray): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        np.ndarray: The tensor with the number replaced.
+    """
+    return np.where(x == num, to, x)
+
+
+def np_guarded_power(x: np.ndarray, exp: float) -> np.ndarray:
+    """Guard the power operation to a valid domain."""
+    return np.power(x, exp) if exp >= 1 else np.power(np.maximum(x, 0), exp)
+
diff --git a/fn_gen/nlr_t_no_sched/11/loss.png b/fn_gen/nlr_t_no_sched/11/loss.png
new file mode 100644
index 0000000000000000000000000000000000000000..f51bd6042d1c330c91ee5406b13998841940712e
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/11/loss.png differ
diff --git a/fn_gen/nlr_t_no_sched/11/quantization.png b/fn_gen/nlr_t_no_sched/11/quantization.png
new file mode 100644
index 0000000000000000000000000000000000000000..114c44936bf8e8e42acc1426bb6a9100f9f30d25
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/11/quantization.png differ
diff --git a/fn_gen/nlr_t_no_sched/12/distortion.png b/fn_gen/nlr_t_no_sched/12/distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..8294b9669ca57e9ac3f196b59416b40934a2725f
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/12/distortion.png differ
diff --git a/fn_gen/nlr_t_no_sched/12/expressions.txt b/fn_gen/nlr_t_no_sched/12/expressions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8c0b1579c06c048d5603aa39c80e392c5906a879
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/12/expressions.txt
@@ -0,0 +1,2 @@
+cos(_0*x)/_s
+acos(_s*x)/_0
\ No newline at end of file
diff --git a/fn_gen/nlr_t_no_sched/12/fn.py b/fn_gen/nlr_t_no_sched/12/fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b0b36143e8b3e80cd8990aa979d1edbad911769
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/12/fn.py
@@ -0,0 +1,479 @@
+from __future__ import annotations
+
+import torch
+from torch import amin  # Necessary for arcsin
+import copy
+import torch.nn as nn
+import numpy as np
+
+from scipy.optimize import curve_fit
+from typing import Dict, Any, Tuple, List, Callable
+
+
+def quantization(x, **params):
+	return (torch.div(1, replace_num(params['_s'], num=0, to=10000)) * torch.cos((params['_0'] * x)))
+
+
+def dequantization(x, **params):
+	return (torch.div(1, replace_num(params['_0'], num=0, to=10000)) * torch.acos(domain_guard((params['_s'] * x), min=-0.99999, max=0.99999, nan=0)))
+
+
+def init_params(x: torch.Tensor, **kwargs: Dict[str, Any]) -> Dict[str, nn.Parameter]:
+	base_p0 = {
+	'_0': init_space_search(x, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], param='_0', **kwargs),
+	}
+
+	base_p0['_s'] = init_linear_scale(x, qtz_func=quantization, params=base_p0, **kwargs)
+	if 'post_init_hook' in kwargs:
+		kwargs['post_init_hook'](parameters=base_p0)
+	
+	params = init_non_linear_regression_fit(x, p0=base_p0, np_fit_func=fit_func, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], **kwargs)
+	params = {k: nn.Parameter(v, requires_grad=False) for k, v in params.items()}
+	if 'post_method_hook' in kwargs:
+		kwargs['post_method_hook'](parameters=params)
+	
+	params = learn_parameters(x, params,
+		qtz_func=quantization,
+		deqtz_func=dequantization,
+		bits=kwargs['bits'],
+		target_dtype=torch.int8,
+		epochs=500,
+		early_stop=False,
+	)
+	if 'post_train_hook' in kwargs:
+		kwargs['post_train_hook'](parameters=params)
+	
+	return params
+
+
+############### Numpy Qtz ###############
+
+
+def np_quantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_s, num=0, to=10000)) * np.cos((_0 * x)))
+
+
+def np_dequantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_0, num=0, to=10000)) * np.arccos(np_domain_guard((_s * x), min=-0.99999, max=0.99999, nan=0)))
+
+
+def fit_func(x, _0, _s):
+    x_ = np_quantization(x, _0, _s)
+    x_ = np_dequantization(x_, _0, _s)
+    return x_
+
+
+
+############### HELPERS ###############
+
+def domain_guard(
+        x: torch.Tensor, 
+        min: float = None, 
+        max: float = None, 
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> torch.Tensor:
+    """Guard a tensor to a valid domain."""
+    x = torch.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = torch.clamp(x, min=min, max=max)
+    return x
+
+
+def replace_num(x: torch.Tensor, num: float, to: float) -> torch.Tensor:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (torch.Tensor): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        torch.Tensor: The tensor with the number replaced.
+    """
+    return torch.where(x == num, to, x)
+
+
+def guarded_torch_power(x: torch.Tensor, exp: float) -> torch.Tensor:
+    """Guard the power operation to a valid domain."""
+    return torch.pow(x, exp) if exp >= 1 else torch.pow(torch.relu(x), exp)
+
+
+def init_ones(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.ones_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_rand(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.randn_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_space_search(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    def _build_initial_param(tensor: torch.Tensor, max_initial: int, n_params: int):
+        """Generates the initial set of parameters. The first iteration generates 10 times more parameters."""
+        for _ in range(n_params * 10):  # The first iteration generates 10 times more parameters
+            yield init_rand(tensor) * max_initial  # Generates n_params in range [-max_initial, max_initial]
+
+    def _search_param(tensors: List[torch.tensor], n_params):
+        """Takes the best parameters and generates new parameters around the mean of the best parameters."""
+        torch_tensors = torch.stack(tensors)
+        min_vals, max_vals = torch.aminmax(torch_tensors, dim=0)
+        abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+        mean = torch.mean(torch_tensors, dim=0)
+        for _ in range(n_params):  # Generates n_params around the mean of the tensors
+            yield torch.randn_like(min_vals) * abs_max_val_per_ch + mean
+
+    def _calc(x, qtz_func, deqtz_func, **params):
+        x_ = x.transpose(0, 1)
+        x_ = qtz_func(x=x_, **params)
+        x_ = deqtz_func(x=x_, **params)
+        x_ = x_.transpose(0, 1)
+        return x_
+
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+    assert "deqtz_func" in kwargs, "deqtz_func must be provided."
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "param" in kwargs, "param must be provided."
+
+    qtz_func = kwargs.get('qtz_func')
+    deqtz_func = kwargs.get('deqtz_func')
+    params_list = kwargs.get('params_list')
+    param = kwargs.get('param')
+
+    n_runs = 50                # Number of runs to try to find the best parameters
+    n_random_params = 50       # Number of random parameters to generate
+    n_best_to_pick = 5         # Number of best parameters to pick after each run
+    max_initial = 10000        # Maximum value to initialize the parameters
+
+    # Initializes the parameters
+    base_params = { p: init_ones(x, **kwargs) for p in params_list if p != param }
+    params = _build_initial_param(x, max_initial, n_random_params)
+
+    # Performs the search
+    for _ in range(n_runs):
+        
+        best_params = []
+        for param_ in params:
+            try:
+                x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: param_})
+                loss_ones = nn.MSELoss()(x, x_)
+
+                if len(best_params) < n_best_to_pick:
+                    best_params.append((param_, loss_ones.item()))
+                    best_params = sorted(best_params, key=lambda x: x[1])
+                elif loss_ones < best_params[-1][1]:
+                    best_params[-1] = (param_, loss_ones.item())
+                    best_params = sorted(best_params, key=lambda x: x[1])
+
+            except Exception:  # The parameters might not be valid for the function's domain
+                continue
+
+        # Generates new parameters around the mean
+        params = _search_param([p for p, _ in best_params], n_random_params)
+
+    # Checks if the best parameter is better than the init_ones
+    p_ones = init_ones(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_ones})
+    loss_ones = nn.MSELoss()(x, x_)
+
+    # Checks if the best parameter is better than the init_rand
+    p_rand = init_rand(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_rand})
+    loss_rand = nn.MSELoss()(x, x_)
+
+    if loss_rand < best_params[0][1] and loss_rand < loss_ones:
+        return p_rand
+    elif loss_ones < best_params[0][1] and loss_ones < loss_rand:
+        return p_ones
+    else:
+        return best_params[0][0]
+
+
+def init_linear_scale(  # Symmetric scale. From the study folder
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+    assert "bits" in kwargs, "bits must be provided."
+    assert "params" in kwargs, "params must be provided."
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+
+    bits = kwargs.get('bits')
+    params = kwargs.get('params')
+    qtz_func = kwargs.get('qtz_func')
+
+    x_ = x.transpose(0, 1)
+    x_ = qtz_func(x=x_, **params, _s=init_ones(x, **kwargs))
+    x_ = x_.transpose(0, 1)
+    
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    min_vals, max_vals = torch.aminmax(x_, dim=1)
+    min_vals = torch.min(min_vals, torch.zeros_like(min_vals))
+    max_vals = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    eps = torch.finfo(torch.float32).eps
+
+    abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+    scale = abs_max_val_per_ch / (float(quant_max - quant_min) / 2)
+    
+    scale = torch.clamp(scale, min=eps).to(dtype=torch.float32, device=min_vals.device)
+
+    # Introduces some noise in scale
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything.
+    # NOTE(diogo): This has been disproven. The noise does not help the learning process but I still
+    # left it here for future reference. Will be removed later.
+    # scale = scale + 0.01 * torch.randn_like(scale)
+
+    return scale
+
+
+def init_non_linear_regression_fit(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "np_fit_func" in kwargs, "np_fit_func must be provided."
+    assert "p0" in kwargs, "p0 must be provided."
+    np_fit_func = kwargs.get('np_fit_func')
+    params_list = kwargs.get('params_list')
+    p0 = kwargs.get('p0')
+
+    def _fit(xdata: np.ndarray, ydata: np.ndarray, func: Callable, p0: List[float]):
+        popt, _ = curve_fit(
+            func, 
+            xdata, 
+            ydata, 
+            maxfev=1000,
+            p0=p0,
+            method='lm'
+        )
+        return popt
+
+    # 1. Needs to convert the torch tensor to numpy tensor
+    xdata = x.cpu().numpy()
+
+    # 2. Sorts the data so that it makes it easier to fit to it
+    sorted_xdata = np.sort(xdata, axis=-1)
+
+    p0 = {k: v.cpu().numpy() for k, v in p0.items()}
+    params_list = sorted(params_list)  # We need to make sure that it matches the numpy fit func arg order
+
+    # 3. Finds the best parameters for each channel
+    try:
+        params = []
+        for i in range(sorted_xdata.shape[0]):
+            xdata_ = sorted_xdata[i]
+            p0_ = [p0[p][i] for p in params_list]
+            ch_params = _fit(xdata_, xdata_, np_fit_func, p0_)
+            params.append(ch_params)
+
+        # 4. Builds the parameters
+        result = {}
+        for i, p in enumerate(params_list):
+            result[p] = torch.tensor([p_[i] for p_ in params], dtype=torch.float32).to(x.device)
+
+        return result
+
+    except ValueError as e:
+        print(f"Could not fit the function with error: {e}")
+        print(f"Using fallback result...")
+        return {
+            k: torch.tensor(v, dtype=torch.float32).to(x.device) for k, v in p0.items()
+        }
+
+
+def init_zeros(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.zeros_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_inner_scale(tensor: torch.Tensor, _min: float = torch.inf, _max: float = torch.inf) -> torch.Tensor:
+    # Calculate the original minimum and maximum values
+    min_vals, max_vals = torch.aminmax(tensor, dim=-1)
+    x_min = torch.min(min_vals, torch.zeros_like(min_vals))
+    x_max = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    if _max is torch.inf:  # We do not need to scale the tensor. Just need to move it
+        return torch.ones_like(x_min)
+    
+    # Calculate the scale factor
+    scale = (_max - _min) / (x_max - x_min)
+    return scale
+
+
+
+############## Quant ###############
+
+@torch.enable_grad()
+def learn_parameters(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    qtz_func: nn.Module,
+    deqtz_func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype,
+    epochs: int = 1000,
+    early_stop: bool = True,
+    do_report: bool = False
+) -> Tuple[Dict[str, nn.Parameter], torch.Tensor]:
+    loss_fn = nn.MSELoss()
+
+    # Determines the initial learning rate by computing the initial loss and multiplying it by
+    # the order of magnitude of the loss divided by 2
+    quant = quantize(x, params, qtz_func, bits, target_dtype)
+    dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+    loss = loss_fn(x, dequant)
+
+    base_lr = 0.1
+    exponent = int(np.floor(np.log10(loss.item())))
+    lr = base_lr * (10 ** (exponent // 2))
+    
+    # Requires gradients in the parameters
+    for p in params.values():
+        p.requires_grad = True
+        p.grad = None
+
+    param_keys = list(params.keys())
+    param_values = list(params.values())
+
+    # Defines optimizer and loss function
+    optimizer = torch.optim.Adam(param_values, lr=lr)
+
+    # Contains the best loss and the best parameters 
+    best_loss = float("inf")
+    best_params = None
+
+    # Used to stop the search early
+    min_delta = 1e-7
+    acc_loss = []
+    percent_epochs_before_stop = 0.1
+
+    for i in range(epochs):
+        optimizer.zero_grad()
+
+        quant = quantize(x, params, qtz_func, bits, target_dtype)
+        dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+        loss = loss_fn(x, dequant)
+
+        if loss.isnan() or loss.isinf():
+            raise Exception("Loss is NaN or Inf. Stopping the search.")
+
+        loss.backward()
+        optimizer.step()
+
+        acc_loss.append(loss.item())
+
+        # Reports loss every 10 steps
+        if i % 10 == 0 and do_report:
+            print(f"Epoch {i}: Loss {loss.item()}")
+
+        # Optimizes the parameter search by storing the best loss and the parameters
+        if loss.item() < best_loss:
+            best_loss = loss.item()
+            best_params = copy.deepcopy({
+                k: v for k, v in params.items() if k in param_keys
+            })
+
+        # We also stop the search if the loss has not considerably during the last 10% epochs
+        if early_stop:
+            epochs_before_stop = int(epochs * percent_epochs_before_stop)
+            if i > epochs_before_stop and abs(acc_loss[i - epochs_before_stop] - acc_loss[i]) < min_delta:
+                break
+
+    # No longer requires gradients in the parameters
+    for p in best_params.values():
+        p.requires_grad = False
+        p.grad = None
+    
+    if do_report:
+        print(f"Best loss: {best_loss}")
+        return best_params, acc_loss
+    else:
+        return best_params
+
+
+def quantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype = torch.int8
+) -> torch.Tensor:
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    x = x.transpose(0, 1)  # Aligns shapes
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    x = torch.clamp(round_func_BPDA(x), quant_min, quant_max).to(target_dtype)
+    return x
+
+
+def dequantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    out_dtype: torch.dtype
+) -> torch.Tensor:
+    x = x.to(dtype=out_dtype)
+    x = x.transpose(0, 1)
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    return x
+
+
+def round_func_BPDA(input):
+    # This is equivalent to replacing round function (non-differentiable) with
+    # an identity function (differentiable) only when backward.
+    forward_value = torch.round(input)
+    out = input.clone()
+    out.data = forward_value.data
+    return out
+
+
+def get_min_max_from_bits_signed(bit_width: int) -> Tuple[int, int]:
+    return -2 ** (bit_width - 1), 2 ** (bit_width - 1) - 1
+
+
+
+############## Numpy ###############
+
+def np_domain_guard(
+        x: np.ndarray,
+        min: float = None,
+        max: float = None,
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> np.ndarray:
+    """Guard a tensor to a valid domain."""
+    x = np.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = np.clip(x, min, max)
+    return x
+
+
+def np_replace_num(x: np.ndarray, num: float, to: float) -> np.ndarray:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (np.ndarray): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        np.ndarray: The tensor with the number replaced.
+    """
+    return np.where(x == num, to, x)
+
+
+def np_guarded_power(x: np.ndarray, exp: float) -> np.ndarray:
+    """Guard the power operation to a valid domain."""
+    return np.power(x, exp) if exp >= 1 else np.power(np.maximum(x, 0), exp)
+
diff --git a/fn_gen/nlr_t_no_sched/12/loss.png b/fn_gen/nlr_t_no_sched/12/loss.png
new file mode 100644
index 0000000000000000000000000000000000000000..c930769ae2f3ba8fdcfebefe32bb589b6a444542
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/12/loss.png differ
diff --git a/fn_gen/nlr_t_no_sched/12/quantization.png b/fn_gen/nlr_t_no_sched/12/quantization.png
new file mode 100644
index 0000000000000000000000000000000000000000..50fb62d93ded88c28978db32d6b09366891a66db
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/12/quantization.png differ
diff --git a/fn_gen/nlr_t_no_sched/14/distortion.png b/fn_gen/nlr_t_no_sched/14/distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..32b258195d9bd90d59a18307260146a982c611a3
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/14/distortion.png differ
diff --git a/fn_gen/nlr_t_no_sched/14/expressions.txt b/fn_gen/nlr_t_no_sched/14/expressions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c545adce8b3c320e195336b81461c79d0cc385e6
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/14/expressions.txt
@@ -0,0 +1,2 @@
+asinh(_0*x)/_s
+sinh(_s*x)/_0
\ No newline at end of file
diff --git a/fn_gen/nlr_t_no_sched/14/fn.py b/fn_gen/nlr_t_no_sched/14/fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d3338bcc81d3b48db214733d543a56a709c47e6
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/14/fn.py
@@ -0,0 +1,479 @@
+from __future__ import annotations
+
+import torch
+from torch import amin  # Necessary for arcsin
+import copy
+import torch.nn as nn
+import numpy as np
+
+from scipy.optimize import curve_fit
+from typing import Dict, Any, Tuple, List, Callable
+
+
+def quantization(x, **params):
+	return (torch.div(1, replace_num(params['_s'], num=0, to=10000)) * torch.asinh((params['_0'] * x)))
+
+
+def dequantization(x, **params):
+	return (torch.div(1, replace_num(params['_0'], num=0, to=10000)) * torch.sinh((params['_s'] * x)))
+
+
+def init_params(x: torch.Tensor, **kwargs: Dict[str, Any]) -> Dict[str, nn.Parameter]:
+	base_p0 = {
+	'_0': init_space_search(x, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], param='_0', **kwargs),
+	}
+
+	base_p0['_s'] = init_linear_scale(x, qtz_func=quantization, params=base_p0, **kwargs)
+	if 'post_init_hook' in kwargs:
+		kwargs['post_init_hook'](parameters=base_p0)
+	
+	params = init_non_linear_regression_fit(x, p0=base_p0, np_fit_func=fit_func, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], **kwargs)
+	params = {k: nn.Parameter(v, requires_grad=False) for k, v in params.items()}
+	if 'post_method_hook' in kwargs:
+		kwargs['post_method_hook'](parameters=params)
+	
+	params = learn_parameters(x, params,
+		qtz_func=quantization,
+		deqtz_func=dequantization,
+		bits=kwargs['bits'],
+		target_dtype=torch.int8,
+		epochs=500,
+		early_stop=False,
+	)
+	if 'post_train_hook' in kwargs:
+		kwargs['post_train_hook'](parameters=params)
+	
+	return params
+
+
+############### Numpy Qtz ###############
+
+
+def np_quantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_s, num=0, to=10000)) * np.arcsinh((_0 * x)))
+
+
+def np_dequantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_0, num=0, to=10000)) * np.sinh((_s * x)))
+
+
+def fit_func(x, _0, _s):
+    x_ = np_quantization(x, _0, _s)
+    x_ = np_dequantization(x_, _0, _s)
+    return x_
+
+
+
+############### HELPERS ###############
+
+def domain_guard(
+        x: torch.Tensor, 
+        min: float = None, 
+        max: float = None, 
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> torch.Tensor:
+    """Guard a tensor to a valid domain."""
+    x = torch.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = torch.clamp(x, min=min, max=max)
+    return x
+
+
+def replace_num(x: torch.Tensor, num: float, to: float) -> torch.Tensor:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (torch.Tensor): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        torch.Tensor: The tensor with the number replaced.
+    """
+    return torch.where(x == num, to, x)
+
+
+def guarded_torch_power(x: torch.Tensor, exp: float) -> torch.Tensor:
+    """Guard the power operation to a valid domain."""
+    return torch.pow(x, exp) if exp >= 1 else torch.pow(torch.relu(x), exp)
+
+
+def init_ones(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.ones_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_rand(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.randn_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_space_search(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    def _build_initial_param(tensor: torch.Tensor, max_initial: int, n_params: int):
+        """Generates the initial set of parameters. The first iteration generates 10 times more parameters."""
+        for _ in range(n_params * 10):  # The first iteration generates 10 times more parameters
+            yield init_rand(tensor) * max_initial  # Generates n_params in range [-max_initial, max_initial]
+
+    def _search_param(tensors: List[torch.tensor], n_params):
+        """Takes the best parameters and generates new parameters around the mean of the best parameters."""
+        torch_tensors = torch.stack(tensors)
+        min_vals, max_vals = torch.aminmax(torch_tensors, dim=0)
+        abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+        mean = torch.mean(torch_tensors, dim=0)
+        for _ in range(n_params):  # Generates n_params around the mean of the tensors
+            yield torch.randn_like(min_vals) * abs_max_val_per_ch + mean
+
+    def _calc(x, qtz_func, deqtz_func, **params):
+        x_ = x.transpose(0, 1)
+        x_ = qtz_func(x=x_, **params)
+        x_ = deqtz_func(x=x_, **params)
+        x_ = x_.transpose(0, 1)
+        return x_
+
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+    assert "deqtz_func" in kwargs, "deqtz_func must be provided."
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "param" in kwargs, "param must be provided."
+
+    qtz_func = kwargs.get('qtz_func')
+    deqtz_func = kwargs.get('deqtz_func')
+    params_list = kwargs.get('params_list')
+    param = kwargs.get('param')
+
+    n_runs = 50                # Number of runs to try to find the best parameters
+    n_random_params = 50       # Number of random parameters to generate
+    n_best_to_pick = 5         # Number of best parameters to pick after each run
+    max_initial = 10000        # Maximum value to initialize the parameters
+
+    # Initializes the parameters
+    base_params = { p: init_ones(x, **kwargs) for p in params_list if p != param }
+    params = _build_initial_param(x, max_initial, n_random_params)
+
+    # Performs the search
+    for _ in range(n_runs):
+        
+        best_params = []
+        for param_ in params:
+            try:
+                x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: param_})
+                loss_ones = nn.MSELoss()(x, x_)
+
+                if len(best_params) < n_best_to_pick:
+                    best_params.append((param_, loss_ones.item()))
+                    best_params = sorted(best_params, key=lambda x: x[1])
+                elif loss_ones < best_params[-1][1]:
+                    best_params[-1] = (param_, loss_ones.item())
+                    best_params = sorted(best_params, key=lambda x: x[1])
+
+            except Exception:  # The parameters might not be valid for the function's domain
+                continue
+
+        # Generates new parameters around the mean
+        params = _search_param([p for p, _ in best_params], n_random_params)
+
+    # Checks if the best parameter is better than the init_ones
+    p_ones = init_ones(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_ones})
+    loss_ones = nn.MSELoss()(x, x_)
+
+    # Checks if the best parameter is better than the init_rand
+    p_rand = init_rand(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_rand})
+    loss_rand = nn.MSELoss()(x, x_)
+
+    if loss_rand < best_params[0][1] and loss_rand < loss_ones:
+        return p_rand
+    elif loss_ones < best_params[0][1] and loss_ones < loss_rand:
+        return p_ones
+    else:
+        return best_params[0][0]
+
+
+def init_linear_scale(  # Symmetric scale. From the study folder
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+    assert "bits" in kwargs, "bits must be provided."
+    assert "params" in kwargs, "params must be provided."
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+
+    bits = kwargs.get('bits')
+    params = kwargs.get('params')
+    qtz_func = kwargs.get('qtz_func')
+
+    x_ = x.transpose(0, 1)
+    x_ = qtz_func(x=x_, **params, _s=init_ones(x, **kwargs))
+    x_ = x_.transpose(0, 1)
+    
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    min_vals, max_vals = torch.aminmax(x_, dim=1)
+    min_vals = torch.min(min_vals, torch.zeros_like(min_vals))
+    max_vals = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    eps = torch.finfo(torch.float32).eps
+
+    abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+    scale = abs_max_val_per_ch / (float(quant_max - quant_min) / 2)
+    
+    scale = torch.clamp(scale, min=eps).to(dtype=torch.float32, device=min_vals.device)
+
+    # Introduces some noise in scale
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything.
+    # NOTE(diogo): This has been disproven. The noise does not help the learning process but I still
+    # left it here for future reference. Will be removed later.
+    # scale = scale + 0.01 * torch.randn_like(scale)
+
+    return scale
+
+
+def init_non_linear_regression_fit(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "np_fit_func" in kwargs, "np_fit_func must be provided."
+    assert "p0" in kwargs, "p0 must be provided."
+    np_fit_func = kwargs.get('np_fit_func')
+    params_list = kwargs.get('params_list')
+    p0 = kwargs.get('p0')
+
+    def _fit(xdata: np.ndarray, ydata: np.ndarray, func: Callable, p0: List[float]):
+        popt, _ = curve_fit(
+            func, 
+            xdata, 
+            ydata, 
+            maxfev=1000,
+            p0=p0,
+            method='lm'
+        )
+        return popt
+
+    # 1. Needs to convert the torch tensor to numpy tensor
+    xdata = x.cpu().numpy()
+
+    # 2. Sorts the data so that it makes it easier to fit to it
+    sorted_xdata = np.sort(xdata, axis=-1)
+
+    p0 = {k: v.cpu().numpy() for k, v in p0.items()}
+    params_list = sorted(params_list)  # We need to make sure that it matches the numpy fit func arg order
+
+    # 3. Finds the best parameters for each channel
+    try:
+        params = []
+        for i in range(sorted_xdata.shape[0]):
+            xdata_ = sorted_xdata[i]
+            p0_ = [p0[p][i] for p in params_list]
+            ch_params = _fit(xdata_, xdata_, np_fit_func, p0_)
+            params.append(ch_params)
+
+        # 4. Builds the parameters
+        result = {}
+        for i, p in enumerate(params_list):
+            result[p] = torch.tensor([p_[i] for p_ in params], dtype=torch.float32).to(x.device)
+
+        return result
+
+    except ValueError as e:
+        print(f"Could not fit the function with error: {e}")
+        print(f"Using fallback result...")
+        return {
+            k: torch.tensor(v, dtype=torch.float32).to(x.device) for k, v in p0.items()
+        }
+
+
+def init_zeros(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.zeros_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_inner_scale(tensor: torch.Tensor, _min: float = torch.inf, _max: float = torch.inf) -> torch.Tensor:
+    # Calculate the original minimum and maximum values
+    min_vals, max_vals = torch.aminmax(tensor, dim=-1)
+    x_min = torch.min(min_vals, torch.zeros_like(min_vals))
+    x_max = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    if _max is torch.inf:  # We do not need to scale the tensor. Just need to move it
+        return torch.ones_like(x_min)
+    
+    # Calculate the scale factor
+    scale = (_max - _min) / (x_max - x_min)
+    return scale
+
+
+
+############## Quant ###############
+
+@torch.enable_grad()
+def learn_parameters(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    qtz_func: nn.Module,
+    deqtz_func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype,
+    epochs: int = 1000,
+    early_stop: bool = True,
+    do_report: bool = False
+) -> Tuple[Dict[str, nn.Parameter], torch.Tensor]:
+    loss_fn = nn.MSELoss()
+
+    # Determines the initial learning rate by computing the initial loss and multiplying it by
+    # the order of magnitude of the loss divided by 2
+    quant = quantize(x, params, qtz_func, bits, target_dtype)
+    dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+    loss = loss_fn(x, dequant)
+
+    base_lr = 0.1
+    exponent = int(np.floor(np.log10(loss.item())))
+    lr = base_lr * (10 ** (exponent // 2))
+    
+    # Requires gradients in the parameters
+    for p in params.values():
+        p.requires_grad = True
+        p.grad = None
+
+    param_keys = list(params.keys())
+    param_values = list(params.values())
+
+    # Defines optimizer and loss function
+    optimizer = torch.optim.Adam(param_values, lr=lr)
+
+    # Contains the best loss and the best parameters 
+    best_loss = float("inf")
+    best_params = None
+
+    # Used to stop the search early
+    min_delta = 1e-7
+    acc_loss = []
+    percent_epochs_before_stop = 0.1
+
+    for i in range(epochs):
+        optimizer.zero_grad()
+
+        quant = quantize(x, params, qtz_func, bits, target_dtype)
+        dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+        loss = loss_fn(x, dequant)
+
+        if loss.isnan() or loss.isinf():
+            raise Exception("Loss is NaN or Inf. Stopping the search.")
+
+        loss.backward()
+        optimizer.step()
+
+        acc_loss.append(loss.item())
+
+        # Reports loss every 10 steps
+        if i % 10 == 0 and do_report:
+            print(f"Epoch {i}: Loss {loss.item()}")
+
+        # Optimizes the parameter search by storing the best loss and the parameters
+        if loss.item() < best_loss:
+            best_loss = loss.item()
+            best_params = copy.deepcopy({
+                k: v for k, v in params.items() if k in param_keys
+            })
+
+        # We also stop the search if the loss has not considerably during the last 10% epochs
+        if early_stop:
+            epochs_before_stop = int(epochs * percent_epochs_before_stop)
+            if i > epochs_before_stop and abs(acc_loss[i - epochs_before_stop] - acc_loss[i]) < min_delta:
+                break
+
+    # No longer requires gradients in the parameters
+    for p in best_params.values():
+        p.requires_grad = False
+        p.grad = None
+    
+    if do_report:
+        print(f"Best loss: {best_loss}")
+        return best_params, acc_loss
+    else:
+        return best_params
+
+
+def quantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype = torch.int8
+) -> torch.Tensor:
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    x = x.transpose(0, 1)  # Aligns shapes
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    x = torch.clamp(round_func_BPDA(x), quant_min, quant_max).to(target_dtype)
+    return x
+
+
+def dequantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    out_dtype: torch.dtype
+) -> torch.Tensor:
+    x = x.to(dtype=out_dtype)
+    x = x.transpose(0, 1)
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    return x
+
+
+def round_func_BPDA(input):
+    # This is equivalent to replacing round function (non-differentiable) with
+    # an identity function (differentiable) only when backward.
+    forward_value = torch.round(input)
+    out = input.clone()
+    out.data = forward_value.data
+    return out
+
+
+def get_min_max_from_bits_signed(bit_width: int) -> Tuple[int, int]:
+    return -2 ** (bit_width - 1), 2 ** (bit_width - 1) - 1
+
+
+
+############## Numpy ###############
+
+def np_domain_guard(
+        x: np.ndarray,
+        min: float = None,
+        max: float = None,
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> np.ndarray:
+    """Guard a tensor to a valid domain."""
+    x = np.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = np.clip(x, min, max)
+    return x
+
+
+def np_replace_num(x: np.ndarray, num: float, to: float) -> np.ndarray:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (np.ndarray): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        np.ndarray: The tensor with the number replaced.
+    """
+    return np.where(x == num, to, x)
+
+
+def np_guarded_power(x: np.ndarray, exp: float) -> np.ndarray:
+    """Guard the power operation to a valid domain."""
+    return np.power(x, exp) if exp >= 1 else np.power(np.maximum(x, 0), exp)
+
diff --git a/fn_gen/nlr_t_no_sched/14/loss.png b/fn_gen/nlr_t_no_sched/14/loss.png
new file mode 100644
index 0000000000000000000000000000000000000000..9cfc29a8df0f1f71b9273b05c87b63cb91d7a02d
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/14/loss.png differ
diff --git a/fn_gen/nlr_t_no_sched/14/quantization.png b/fn_gen/nlr_t_no_sched/14/quantization.png
new file mode 100644
index 0000000000000000000000000000000000000000..aa840dd350198b545e897d354ac2f52d526f3c7a
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/14/quantization.png differ
diff --git a/fn_gen/nlr_t_no_sched/16/distortion.png b/fn_gen/nlr_t_no_sched/16/distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..ce433146aba9c92696b85bd77105a376e1066bc3
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/16/distortion.png differ
diff --git a/fn_gen/nlr_t_no_sched/16/expressions.txt b/fn_gen/nlr_t_no_sched/16/expressions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..23606e9f370f2e4adb43ed623c49d7fcaabd7355
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/16/expressions.txt
@@ -0,0 +1,2 @@
+tan(_0*x)/_s
+atan(_s*x)/_0
\ No newline at end of file
diff --git a/fn_gen/nlr_t_no_sched/16/fn.py b/fn_gen/nlr_t_no_sched/16/fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..c3aeea812e8380ea610c1fa394b659b143e1ed80
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/16/fn.py
@@ -0,0 +1,479 @@
+from __future__ import annotations
+
+import torch
+from torch import amin  # Necessary for arcsin
+import copy
+import torch.nn as nn
+import numpy as np
+
+from scipy.optimize import curve_fit
+from typing import Dict, Any, Tuple, List, Callable
+
+
+def quantization(x, **params):
+	return (torch.div(1, replace_num(params['_s'], num=0, to=10000)) * torch.tan(domain_guard((params['_0'] * x), posinf=1, neginf=-1, nan=0)))
+
+
+def dequantization(x, **params):
+	return (torch.div(1, replace_num(params['_0'], num=0, to=10000)) * torch.atan((params['_s'] * x)))
+
+
+def init_params(x: torch.Tensor, **kwargs: Dict[str, Any]) -> Dict[str, nn.Parameter]:
+	base_p0 = {
+	'_0': init_space_search(x, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], param='_0', **kwargs),
+	}
+
+	base_p0['_s'] = init_linear_scale(x, qtz_func=quantization, params=base_p0, **kwargs)
+	if 'post_init_hook' in kwargs:
+		kwargs['post_init_hook'](parameters=base_p0)
+	
+	params = init_non_linear_regression_fit(x, p0=base_p0, np_fit_func=fit_func, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], **kwargs)
+	params = {k: nn.Parameter(v, requires_grad=False) for k, v in params.items()}
+	if 'post_method_hook' in kwargs:
+		kwargs['post_method_hook'](parameters=params)
+	
+	params = learn_parameters(x, params,
+		qtz_func=quantization,
+		deqtz_func=dequantization,
+		bits=kwargs['bits'],
+		target_dtype=torch.int8,
+		epochs=500,
+		early_stop=False,
+	)
+	if 'post_train_hook' in kwargs:
+		kwargs['post_train_hook'](parameters=params)
+	
+	return params
+
+
+############### Numpy Qtz ###############
+
+
+def np_quantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_s, num=0, to=10000)) * np.tan(np_domain_guard((_0 * x), posinf=1, neginf=-1, nan=0)))
+
+
+def np_dequantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_0, num=0, to=10000)) * np.arctan((_s * x)))
+
+
+def fit_func(x, _0, _s):
+    x_ = np_quantization(x, _0, _s)
+    x_ = np_dequantization(x_, _0, _s)
+    return x_
+
+
+
+############### HELPERS ###############
+
+def domain_guard(
+        x: torch.Tensor, 
+        min: float = None, 
+        max: float = None, 
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> torch.Tensor:
+    """Guard a tensor to a valid domain."""
+    x = torch.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = torch.clamp(x, min=min, max=max)
+    return x
+
+
+def replace_num(x: torch.Tensor, num: float, to: float) -> torch.Tensor:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (torch.Tensor): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        torch.Tensor: The tensor with the number replaced.
+    """
+    return torch.where(x == num, to, x)
+
+
+def guarded_torch_power(x: torch.Tensor, exp: float) -> torch.Tensor:
+    """Guard the power operation to a valid domain."""
+    return torch.pow(x, exp) if exp >= 1 else torch.pow(torch.relu(x), exp)
+
+
+def init_ones(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.ones_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_rand(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.randn_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_space_search(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    def _build_initial_param(tensor: torch.Tensor, max_initial: int, n_params: int):
+        """Generates the initial set of parameters. The first iteration generates 10 times more parameters."""
+        for _ in range(n_params * 10):  # The first iteration generates 10 times more parameters
+            yield init_rand(tensor) * max_initial  # Generates n_params in range [-max_initial, max_initial]
+
+    def _search_param(tensors: List[torch.tensor], n_params):
+        """Takes the best parameters and generates new parameters around the mean of the best parameters."""
+        torch_tensors = torch.stack(tensors)
+        min_vals, max_vals = torch.aminmax(torch_tensors, dim=0)
+        abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+        mean = torch.mean(torch_tensors, dim=0)
+        for _ in range(n_params):  # Generates n_params around the mean of the tensors
+            yield torch.randn_like(min_vals) * abs_max_val_per_ch + mean
+
+    def _calc(x, qtz_func, deqtz_func, **params):
+        x_ = x.transpose(0, 1)
+        x_ = qtz_func(x=x_, **params)
+        x_ = deqtz_func(x=x_, **params)
+        x_ = x_.transpose(0, 1)
+        return x_
+
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+    assert "deqtz_func" in kwargs, "deqtz_func must be provided."
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "param" in kwargs, "param must be provided."
+
+    qtz_func = kwargs.get('qtz_func')
+    deqtz_func = kwargs.get('deqtz_func')
+    params_list = kwargs.get('params_list')
+    param = kwargs.get('param')
+
+    n_runs = 50                # Number of runs to try to find the best parameters
+    n_random_params = 50       # Number of random parameters to generate
+    n_best_to_pick = 5         # Number of best parameters to pick after each run
+    max_initial = 10000        # Maximum value to initialize the parameters
+
+    # Initializes the parameters
+    base_params = { p: init_ones(x, **kwargs) for p in params_list if p != param }
+    params = _build_initial_param(x, max_initial, n_random_params)
+
+    # Performs the search
+    for _ in range(n_runs):
+        
+        best_params = []
+        for param_ in params:
+            try:
+                x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: param_})
+                loss_ones = nn.MSELoss()(x, x_)
+
+                if len(best_params) < n_best_to_pick:
+                    best_params.append((param_, loss_ones.item()))
+                    best_params = sorted(best_params, key=lambda x: x[1])
+                elif loss_ones < best_params[-1][1]:
+                    best_params[-1] = (param_, loss_ones.item())
+                    best_params = sorted(best_params, key=lambda x: x[1])
+
+            except Exception:  # The parameters might not be valid for the function's domain
+                continue
+
+        # Generates new parameters around the mean
+        params = _search_param([p for p, _ in best_params], n_random_params)
+
+    # Checks if the best parameter is better than the init_ones
+    p_ones = init_ones(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_ones})
+    loss_ones = nn.MSELoss()(x, x_)
+
+    # Checks if the best parameter is better than the init_rand
+    p_rand = init_rand(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_rand})
+    loss_rand = nn.MSELoss()(x, x_)
+
+    if loss_rand < best_params[0][1] and loss_rand < loss_ones:
+        return p_rand
+    elif loss_ones < best_params[0][1] and loss_ones < loss_rand:
+        return p_ones
+    else:
+        return best_params[0][0]
+
+
+def init_linear_scale(  # Symmetric scale. From the study folder
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+    assert "bits" in kwargs, "bits must be provided."
+    assert "params" in kwargs, "params must be provided."
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+
+    bits = kwargs.get('bits')
+    params = kwargs.get('params')
+    qtz_func = kwargs.get('qtz_func')
+
+    x_ = x.transpose(0, 1)
+    x_ = qtz_func(x=x_, **params, _s=init_ones(x, **kwargs))
+    x_ = x_.transpose(0, 1)
+    
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    min_vals, max_vals = torch.aminmax(x_, dim=1)
+    min_vals = torch.min(min_vals, torch.zeros_like(min_vals))
+    max_vals = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    eps = torch.finfo(torch.float32).eps
+
+    abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+    scale = abs_max_val_per_ch / (float(quant_max - quant_min) / 2)
+    
+    scale = torch.clamp(scale, min=eps).to(dtype=torch.float32, device=min_vals.device)
+
+    # Introduces some noise in scale
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything.
+    # NOTE(diogo): This has been disproven. The noise does not help the learning process but I still
+    # left it here for future reference. Will be removed later.
+    # scale = scale + 0.01 * torch.randn_like(scale)
+
+    return scale
+
+
+def init_non_linear_regression_fit(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "np_fit_func" in kwargs, "np_fit_func must be provided."
+    assert "p0" in kwargs, "p0 must be provided."
+    np_fit_func = kwargs.get('np_fit_func')
+    params_list = kwargs.get('params_list')
+    p0 = kwargs.get('p0')
+
+    def _fit(xdata: np.ndarray, ydata: np.ndarray, func: Callable, p0: List[float]):
+        popt, _ = curve_fit(
+            func, 
+            xdata, 
+            ydata, 
+            maxfev=1000,
+            p0=p0,
+            method='lm'
+        )
+        return popt
+
+    # 1. Needs to convert the torch tensor to numpy tensor
+    xdata = x.cpu().numpy()
+
+    # 2. Sorts the data so that it makes it easier to fit to it
+    sorted_xdata = np.sort(xdata, axis=-1)
+
+    p0 = {k: v.cpu().numpy() for k, v in p0.items()}
+    params_list = sorted(params_list)  # We need to make sure that it matches the numpy fit func arg order
+
+    # 3. Finds the best parameters for each channel
+    try:
+        params = []
+        for i in range(sorted_xdata.shape[0]):
+            xdata_ = sorted_xdata[i]
+            p0_ = [p0[p][i] for p in params_list]
+            ch_params = _fit(xdata_, xdata_, np_fit_func, p0_)
+            params.append(ch_params)
+
+        # 4. Builds the parameters
+        result = {}
+        for i, p in enumerate(params_list):
+            result[p] = torch.tensor([p_[i] for p_ in params], dtype=torch.float32).to(x.device)
+
+        return result
+
+    except ValueError as e:
+        print(f"Could not fit the function with error: {e}")
+        print(f"Using fallback result...")
+        return {
+            k: torch.tensor(v, dtype=torch.float32).to(x.device) for k, v in p0.items()
+        }
+
+
+def init_zeros(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.zeros_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_inner_scale(tensor: torch.Tensor, _min: float = torch.inf, _max: float = torch.inf) -> torch.Tensor:
+    # Calculate the original minimum and maximum values
+    min_vals, max_vals = torch.aminmax(tensor, dim=-1)
+    x_min = torch.min(min_vals, torch.zeros_like(min_vals))
+    x_max = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    if _max is torch.inf:  # We do not need to scale the tensor. Just need to move it
+        return torch.ones_like(x_min)
+    
+    # Calculate the scale factor
+    scale = (_max - _min) / (x_max - x_min)
+    return scale
+
+
+
+############## Quant ###############
+
+@torch.enable_grad()
+def learn_parameters(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    qtz_func: nn.Module,
+    deqtz_func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype,
+    epochs: int = 1000,
+    early_stop: bool = True,
+    do_report: bool = False
+) -> Tuple[Dict[str, nn.Parameter], torch.Tensor]:
+    loss_fn = nn.MSELoss()
+
+    # Determines the initial learning rate by computing the initial loss and multiplying it by
+    # the order of magnitude of the loss divided by 2
+    quant = quantize(x, params, qtz_func, bits, target_dtype)
+    dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+    loss = loss_fn(x, dequant)
+
+    base_lr = 0.1
+    exponent = int(np.floor(np.log10(loss.item())))
+    lr = base_lr * (10 ** (exponent // 2))
+    
+    # Requires gradients in the parameters
+    for p in params.values():
+        p.requires_grad = True
+        p.grad = None
+
+    param_keys = list(params.keys())
+    param_values = list(params.values())
+
+    # Defines optimizer and loss function
+    optimizer = torch.optim.Adam(param_values, lr=lr)
+
+    # Contains the best loss and the best parameters 
+    best_loss = float("inf")
+    best_params = None
+
+    # Used to stop the search early
+    min_delta = 1e-7
+    acc_loss = []
+    percent_epochs_before_stop = 0.1
+
+    for i in range(epochs):
+        optimizer.zero_grad()
+
+        quant = quantize(x, params, qtz_func, bits, target_dtype)
+        dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+        loss = loss_fn(x, dequant)
+
+        if loss.isnan() or loss.isinf():
+            raise Exception("Loss is NaN or Inf. Stopping the search.")
+
+        loss.backward()
+        optimizer.step()
+
+        acc_loss.append(loss.item())
+
+        # Reports loss every 10 steps
+        if i % 10 == 0 and do_report:
+            print(f"Epoch {i}: Loss {loss.item()}")
+
+        # Optimizes the parameter search by storing the best loss and the parameters
+        if loss.item() < best_loss:
+            best_loss = loss.item()
+            best_params = copy.deepcopy({
+                k: v for k, v in params.items() if k in param_keys
+            })
+
+        # We also stop the search if the loss has not considerably during the last 10% epochs
+        if early_stop:
+            epochs_before_stop = int(epochs * percent_epochs_before_stop)
+            if i > epochs_before_stop and abs(acc_loss[i - epochs_before_stop] - acc_loss[i]) < min_delta:
+                break
+
+    # No longer requires gradients in the parameters
+    for p in best_params.values():
+        p.requires_grad = False
+        p.grad = None
+    
+    if do_report:
+        print(f"Best loss: {best_loss}")
+        return best_params, acc_loss
+    else:
+        return best_params
+
+
+def quantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype = torch.int8
+) -> torch.Tensor:
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    x = x.transpose(0, 1)  # Aligns shapes
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    x = torch.clamp(round_func_BPDA(x), quant_min, quant_max).to(target_dtype)
+    return x
+
+
+def dequantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    out_dtype: torch.dtype
+) -> torch.Tensor:
+    x = x.to(dtype=out_dtype)
+    x = x.transpose(0, 1)
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    return x
+
+
+def round_func_BPDA(input):
+    # This is equivalent to replacing round function (non-differentiable) with
+    # an identity function (differentiable) only when backward.
+    forward_value = torch.round(input)
+    out = input.clone()
+    out.data = forward_value.data
+    return out
+
+
+def get_min_max_from_bits_signed(bit_width: int) -> Tuple[int, int]:
+    return -2 ** (bit_width - 1), 2 ** (bit_width - 1) - 1
+
+
+
+############## Numpy ###############
+
+def np_domain_guard(
+        x: np.ndarray,
+        min: float = None,
+        max: float = None,
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> np.ndarray:
+    """Guard a tensor to a valid domain."""
+    x = np.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = np.clip(x, min, max)
+    return x
+
+
+def np_replace_num(x: np.ndarray, num: float, to: float) -> np.ndarray:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (np.ndarray): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        np.ndarray: The tensor with the number replaced.
+    """
+    return np.where(x == num, to, x)
+
+
+def np_guarded_power(x: np.ndarray, exp: float) -> np.ndarray:
+    """Guard the power operation to a valid domain."""
+    return np.power(x, exp) if exp >= 1 else np.power(np.maximum(x, 0), exp)
+
diff --git a/fn_gen/nlr_t_no_sched/16/loss.png b/fn_gen/nlr_t_no_sched/16/loss.png
new file mode 100644
index 0000000000000000000000000000000000000000..c340583b13db39222aa0308b99a3b8e3d388ca30
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/16/loss.png differ
diff --git a/fn_gen/nlr_t_no_sched/16/quantization.png b/fn_gen/nlr_t_no_sched/16/quantization.png
new file mode 100644
index 0000000000000000000000000000000000000000..a073d5c00f52a2a15a97a832a73285bc35f9f545
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/16/quantization.png differ
diff --git a/fn_gen/nlr_t_no_sched/17/distortion.png b/fn_gen/nlr_t_no_sched/17/distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..e9c3a9170ca94ac83d186c60664f6725ca840f6d
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/17/distortion.png differ
diff --git a/fn_gen/nlr_t_no_sched/17/expressions.txt b/fn_gen/nlr_t_no_sched/17/expressions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ed99293c42843616c361d59b23d32ae553cc0f8d
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/17/expressions.txt
@@ -0,0 +1,2 @@
+atanh(_0*x)/_s
+tanh(_s*x)/_0
\ No newline at end of file
diff --git a/fn_gen/nlr_t_no_sched/17/fn.py b/fn_gen/nlr_t_no_sched/17/fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..b2096560367348ae29f0e8a1f833bc8cee7f36de
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/17/fn.py
@@ -0,0 +1,479 @@
+from __future__ import annotations
+
+import torch
+from torch import amin  # Necessary for arcsin
+import copy
+import torch.nn as nn
+import numpy as np
+
+from scipy.optimize import curve_fit
+from typing import Dict, Any, Tuple, List, Callable
+
+
+def quantization(x, **params):
+	return (torch.div(1, replace_num(params['_s'], num=0, to=10000)) * torch.atanh(domain_guard((params['_0'] * x), min=-0.9999, max=0.9999, nan=0)))
+
+
+def dequantization(x, **params):
+	return (torch.div(1, replace_num(params['_0'], num=0, to=10000)) * torch.tanh((params['_s'] * x)))
+
+
+def init_params(x: torch.Tensor, **kwargs: Dict[str, Any]) -> Dict[str, nn.Parameter]:
+	base_p0 = {
+	'_0': init_space_search(x, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], param='_0', **kwargs),
+	}
+
+	base_p0['_s'] = init_linear_scale(x, qtz_func=quantization, params=base_p0, **kwargs)
+	if 'post_init_hook' in kwargs:
+		kwargs['post_init_hook'](parameters=base_p0)
+	
+	params = init_non_linear_regression_fit(x, p0=base_p0, np_fit_func=fit_func, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], **kwargs)
+	params = {k: nn.Parameter(v, requires_grad=False) for k, v in params.items()}
+	if 'post_method_hook' in kwargs:
+		kwargs['post_method_hook'](parameters=params)
+	
+	params = learn_parameters(x, params,
+		qtz_func=quantization,
+		deqtz_func=dequantization,
+		bits=kwargs['bits'],
+		target_dtype=torch.int8,
+		epochs=500,
+		early_stop=False,
+	)
+	if 'post_train_hook' in kwargs:
+		kwargs['post_train_hook'](parameters=params)
+	
+	return params
+
+
+############### Numpy Qtz ###############
+
+
+def np_quantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_s, num=0, to=10000)) * np.arctanh(np_domain_guard((_0 * x), min=-0.9999, max=0.9999, nan=0)))
+
+
+def np_dequantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_0, num=0, to=10000)) * np.tanh((_s * x)))
+
+
+def fit_func(x, _0, _s):
+    x_ = np_quantization(x, _0, _s)
+    x_ = np_dequantization(x_, _0, _s)
+    return x_
+
+
+
+############### HELPERS ###############
+
+def domain_guard(
+        x: torch.Tensor, 
+        min: float = None, 
+        max: float = None, 
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> torch.Tensor:
+    """Guard a tensor to a valid domain."""
+    x = torch.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = torch.clamp(x, min=min, max=max)
+    return x
+
+
+def replace_num(x: torch.Tensor, num: float, to: float) -> torch.Tensor:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (torch.Tensor): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        torch.Tensor: The tensor with the number replaced.
+    """
+    return torch.where(x == num, to, x)
+
+
+def guarded_torch_power(x: torch.Tensor, exp: float) -> torch.Tensor:
+    """Guard the power operation to a valid domain."""
+    return torch.pow(x, exp) if exp >= 1 else torch.pow(torch.relu(x), exp)
+
+
+def init_ones(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.ones_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_rand(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.randn_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_space_search(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    def _build_initial_param(tensor: torch.Tensor, max_initial: int, n_params: int):
+        """Generates the initial set of parameters. The first iteration generates 10 times more parameters."""
+        for _ in range(n_params * 10):  # The first iteration generates 10 times more parameters
+            yield init_rand(tensor) * max_initial  # Generates n_params in range [-max_initial, max_initial]
+
+    def _search_param(tensors: List[torch.tensor], n_params):
+        """Takes the best parameters and generates new parameters around the mean of the best parameters."""
+        torch_tensors = torch.stack(tensors)
+        min_vals, max_vals = torch.aminmax(torch_tensors, dim=0)
+        abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+        mean = torch.mean(torch_tensors, dim=0)
+        for _ in range(n_params):  # Generates n_params around the mean of the tensors
+            yield torch.randn_like(min_vals) * abs_max_val_per_ch + mean
+
+    def _calc(x, qtz_func, deqtz_func, **params):
+        x_ = x.transpose(0, 1)
+        x_ = qtz_func(x=x_, **params)
+        x_ = deqtz_func(x=x_, **params)
+        x_ = x_.transpose(0, 1)
+        return x_
+
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+    assert "deqtz_func" in kwargs, "deqtz_func must be provided."
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "param" in kwargs, "param must be provided."
+
+    qtz_func = kwargs.get('qtz_func')
+    deqtz_func = kwargs.get('deqtz_func')
+    params_list = kwargs.get('params_list')
+    param = kwargs.get('param')
+
+    n_runs = 50                # Number of runs to try to find the best parameters
+    n_random_params = 50       # Number of random parameters to generate
+    n_best_to_pick = 5         # Number of best parameters to pick after each run
+    max_initial = 10000        # Maximum value to initialize the parameters
+
+    # Initializes the parameters
+    base_params = { p: init_ones(x, **kwargs) for p in params_list if p != param }
+    params = _build_initial_param(x, max_initial, n_random_params)
+
+    # Performs the search
+    for _ in range(n_runs):
+        
+        best_params = []
+        for param_ in params:
+            try:
+                x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: param_})
+                loss_ones = nn.MSELoss()(x, x_)
+
+                if len(best_params) < n_best_to_pick:
+                    best_params.append((param_, loss_ones.item()))
+                    best_params = sorted(best_params, key=lambda x: x[1])
+                elif loss_ones < best_params[-1][1]:
+                    best_params[-1] = (param_, loss_ones.item())
+                    best_params = sorted(best_params, key=lambda x: x[1])
+
+            except Exception:  # The parameters might not be valid for the function's domain
+                continue
+
+        # Generates new parameters around the mean
+        params = _search_param([p for p, _ in best_params], n_random_params)
+
+    # Checks if the best parameter is better than the init_ones
+    p_ones = init_ones(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_ones})
+    loss_ones = nn.MSELoss()(x, x_)
+
+    # Checks if the best parameter is better than the init_rand
+    p_rand = init_rand(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_rand})
+    loss_rand = nn.MSELoss()(x, x_)
+
+    if loss_rand < best_params[0][1] and loss_rand < loss_ones:
+        return p_rand
+    elif loss_ones < best_params[0][1] and loss_ones < loss_rand:
+        return p_ones
+    else:
+        return best_params[0][0]
+
+
+def init_linear_scale(  # Symmetric scale. From the study folder
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+    assert "bits" in kwargs, "bits must be provided."
+    assert "params" in kwargs, "params must be provided."
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+
+    bits = kwargs.get('bits')
+    params = kwargs.get('params')
+    qtz_func = kwargs.get('qtz_func')
+
+    x_ = x.transpose(0, 1)
+    x_ = qtz_func(x=x_, **params, _s=init_ones(x, **kwargs))
+    x_ = x_.transpose(0, 1)
+    
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    min_vals, max_vals = torch.aminmax(x_, dim=1)
+    min_vals = torch.min(min_vals, torch.zeros_like(min_vals))
+    max_vals = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    eps = torch.finfo(torch.float32).eps
+
+    abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+    scale = abs_max_val_per_ch / (float(quant_max - quant_min) / 2)
+    
+    scale = torch.clamp(scale, min=eps).to(dtype=torch.float32, device=min_vals.device)
+
+    # Introduces some noise in scale
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything.
+    # NOTE(diogo): This has been disproven. The noise does not help the learning process but I still
+    # left it here for future reference. Will be removed later.
+    # scale = scale + 0.01 * torch.randn_like(scale)
+
+    return scale
+
+
+def init_non_linear_regression_fit(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "np_fit_func" in kwargs, "np_fit_func must be provided."
+    assert "p0" in kwargs, "p0 must be provided."
+    np_fit_func = kwargs.get('np_fit_func')
+    params_list = kwargs.get('params_list')
+    p0 = kwargs.get('p0')
+
+    def _fit(xdata: np.ndarray, ydata: np.ndarray, func: Callable, p0: List[float]):
+        popt, _ = curve_fit(
+            func, 
+            xdata, 
+            ydata, 
+            maxfev=1000,
+            p0=p0,
+            method='lm'
+        )
+        return popt
+
+    # 1. Needs to convert the torch tensor to numpy tensor
+    xdata = x.cpu().numpy()
+
+    # 2. Sorts the data so that it makes it easier to fit to it
+    sorted_xdata = np.sort(xdata, axis=-1)
+
+    p0 = {k: v.cpu().numpy() for k, v in p0.items()}
+    params_list = sorted(params_list)  # We need to make sure that it matches the numpy fit func arg order
+
+    # 3. Finds the best parameters for each channel
+    try:
+        params = []
+        for i in range(sorted_xdata.shape[0]):
+            xdata_ = sorted_xdata[i]
+            p0_ = [p0[p][i] for p in params_list]
+            ch_params = _fit(xdata_, xdata_, np_fit_func, p0_)
+            params.append(ch_params)
+
+        # 4. Builds the parameters
+        result = {}
+        for i, p in enumerate(params_list):
+            result[p] = torch.tensor([p_[i] for p_ in params], dtype=torch.float32).to(x.device)
+
+        return result
+
+    except ValueError as e:
+        print(f"Could not fit the function with error: {e}")
+        print(f"Using fallback result...")
+        return {
+            k: torch.tensor(v, dtype=torch.float32).to(x.device) for k, v in p0.items()
+        }
+
+
+def init_zeros(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.zeros_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_inner_scale(tensor: torch.Tensor, _min: float = torch.inf, _max: float = torch.inf) -> torch.Tensor:
+    # Calculate the original minimum and maximum values
+    min_vals, max_vals = torch.aminmax(tensor, dim=-1)
+    x_min = torch.min(min_vals, torch.zeros_like(min_vals))
+    x_max = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    if _max is torch.inf:  # We do not need to scale the tensor. Just need to move it
+        return torch.ones_like(x_min)
+    
+    # Calculate the scale factor
+    scale = (_max - _min) / (x_max - x_min)
+    return scale
+
+
+
+############## Quant ###############
+
+@torch.enable_grad()
+def learn_parameters(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    qtz_func: nn.Module,
+    deqtz_func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype,
+    epochs: int = 1000,
+    early_stop: bool = True,
+    do_report: bool = False
+) -> Tuple[Dict[str, nn.Parameter], torch.Tensor]:
+    loss_fn = nn.MSELoss()
+
+    # Determines the initial learning rate by computing the initial loss and multiplying it by
+    # the order of magnitude of the loss divided by 2
+    quant = quantize(x, params, qtz_func, bits, target_dtype)
+    dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+    loss = loss_fn(x, dequant)
+
+    base_lr = 0.1
+    exponent = int(np.floor(np.log10(loss.item())))
+    lr = base_lr * (10 ** (exponent // 2))
+    
+    # Requires gradients in the parameters
+    for p in params.values():
+        p.requires_grad = True
+        p.grad = None
+
+    param_keys = list(params.keys())
+    param_values = list(params.values())
+
+    # Defines optimizer and loss function
+    optimizer = torch.optim.Adam(param_values, lr=lr)
+
+    # Contains the best loss and the best parameters 
+    best_loss = float("inf")
+    best_params = None
+
+    # Used to stop the search early
+    min_delta = 1e-7
+    acc_loss = []
+    percent_epochs_before_stop = 0.1
+
+    for i in range(epochs):
+        optimizer.zero_grad()
+
+        quant = quantize(x, params, qtz_func, bits, target_dtype)
+        dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+        loss = loss_fn(x, dequant)
+
+        if loss.isnan() or loss.isinf():
+            raise Exception("Loss is NaN or Inf. Stopping the search.")
+
+        loss.backward()
+        optimizer.step()
+
+        acc_loss.append(loss.item())
+
+        # Reports loss every 10 steps
+        if i % 10 == 0 and do_report:
+            print(f"Epoch {i}: Loss {loss.item()}")
+
+        # Optimizes the parameter search by storing the best loss and the parameters
+        if loss.item() < best_loss:
+            best_loss = loss.item()
+            best_params = copy.deepcopy({
+                k: v for k, v in params.items() if k in param_keys
+            })
+
+        # We also stop the search if the loss has not considerably during the last 10% epochs
+        if early_stop:
+            epochs_before_stop = int(epochs * percent_epochs_before_stop)
+            if i > epochs_before_stop and abs(acc_loss[i - epochs_before_stop] - acc_loss[i]) < min_delta:
+                break
+
+    # No longer requires gradients in the parameters
+    for p in best_params.values():
+        p.requires_grad = False
+        p.grad = None
+    
+    if do_report:
+        print(f"Best loss: {best_loss}")
+        return best_params, acc_loss
+    else:
+        return best_params
+
+
+def quantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype = torch.int8
+) -> torch.Tensor:
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    x = x.transpose(0, 1)  # Aligns shapes
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    x = torch.clamp(round_func_BPDA(x), quant_min, quant_max).to(target_dtype)
+    return x
+
+
+def dequantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    out_dtype: torch.dtype
+) -> torch.Tensor:
+    x = x.to(dtype=out_dtype)
+    x = x.transpose(0, 1)
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    return x
+
+
+def round_func_BPDA(input):
+    # This is equivalent to replacing round function (non-differentiable) with
+    # an identity function (differentiable) only when backward.
+    forward_value = torch.round(input)
+    out = input.clone()
+    out.data = forward_value.data
+    return out
+
+
+def get_min_max_from_bits_signed(bit_width: int) -> Tuple[int, int]:
+    return -2 ** (bit_width - 1), 2 ** (bit_width - 1) - 1
+
+
+
+############## Numpy ###############
+
+def np_domain_guard(
+        x: np.ndarray,
+        min: float = None,
+        max: float = None,
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> np.ndarray:
+    """Guard a tensor to a valid domain."""
+    x = np.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = np.clip(x, min, max)
+    return x
+
+
+def np_replace_num(x: np.ndarray, num: float, to: float) -> np.ndarray:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (np.ndarray): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        np.ndarray: The tensor with the number replaced.
+    """
+    return np.where(x == num, to, x)
+
+
+def np_guarded_power(x: np.ndarray, exp: float) -> np.ndarray:
+    """Guard the power operation to a valid domain."""
+    return np.power(x, exp) if exp >= 1 else np.power(np.maximum(x, 0), exp)
+
diff --git a/fn_gen/nlr_t_no_sched/17/loss.png b/fn_gen/nlr_t_no_sched/17/loss.png
new file mode 100644
index 0000000000000000000000000000000000000000..ffbb3e21d1a2736a171b651dac63e4c25771adcf
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/17/loss.png differ
diff --git a/fn_gen/nlr_t_no_sched/17/quantization.png b/fn_gen/nlr_t_no_sched/17/quantization.png
new file mode 100644
index 0000000000000000000000000000000000000000..af4d4049cae2f0ca57c9c87091d69479348e57c9
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/17/quantization.png differ
diff --git a/fn_gen/nlr_t_no_sched/18/distortion.png b/fn_gen/nlr_t_no_sched/18/distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..91ee3eb08065c6f295eb137f6f01b7c4316ebfba
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/18/distortion.png differ
diff --git a/fn_gen/nlr_t_no_sched/18/expressions.txt b/fn_gen/nlr_t_no_sched/18/expressions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..576ec6a351e26f9982eb17e394804ca906d4b067
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/18/expressions.txt
@@ -0,0 +1,2 @@
+acos(_0*x)/_s
+cos(_s*x)/_0
\ No newline at end of file
diff --git a/fn_gen/nlr_t_no_sched/18/fn.py b/fn_gen/nlr_t_no_sched/18/fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8701b136d5465dc08c5d76cfd8f0069bf1cdd7e
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/18/fn.py
@@ -0,0 +1,479 @@
+from __future__ import annotations
+
+import torch
+from torch import amin  # Necessary for arcsin
+import copy
+import torch.nn as nn
+import numpy as np
+
+from scipy.optimize import curve_fit
+from typing import Dict, Any, Tuple, List, Callable
+
+
+def quantization(x, **params):
+	return (torch.div(1, replace_num(params['_s'], num=0, to=10000)) * torch.acos(domain_guard((params['_0'] * x), min=-0.99999, max=0.99999, nan=0)))
+
+
+def dequantization(x, **params):
+	return (torch.div(1, replace_num(params['_0'], num=0, to=10000)) * torch.cos((params['_s'] * x)))
+
+
+def init_params(x: torch.Tensor, **kwargs: Dict[str, Any]) -> Dict[str, nn.Parameter]:
+	base_p0 = {
+	'_0': init_space_search(x, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], param='_0', **kwargs),
+	}
+
+	base_p0['_s'] = init_linear_scale(x, qtz_func=quantization, params=base_p0, **kwargs)
+	if 'post_init_hook' in kwargs:
+		kwargs['post_init_hook'](parameters=base_p0)
+	
+	params = init_non_linear_regression_fit(x, p0=base_p0, np_fit_func=fit_func, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], **kwargs)
+	params = {k: nn.Parameter(v, requires_grad=False) for k, v in params.items()}
+	if 'post_method_hook' in kwargs:
+		kwargs['post_method_hook'](parameters=params)
+	
+	params = learn_parameters(x, params,
+		qtz_func=quantization,
+		deqtz_func=dequantization,
+		bits=kwargs['bits'],
+		target_dtype=torch.int8,
+		epochs=500,
+		early_stop=False,
+	)
+	if 'post_train_hook' in kwargs:
+		kwargs['post_train_hook'](parameters=params)
+	
+	return params
+
+
+############### Numpy Qtz ###############
+
+
+def np_quantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_s, num=0, to=10000)) * np.arccos(np_domain_guard((_0 * x), min=-0.99999, max=0.99999, nan=0)))
+
+
+def np_dequantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_0, num=0, to=10000)) * np.cos((_s * x)))
+
+
+def fit_func(x, _0, _s):
+    x_ = np_quantization(x, _0, _s)
+    x_ = np_dequantization(x_, _0, _s)
+    return x_
+
+
+
+############### HELPERS ###############
+
+def domain_guard(
+        x: torch.Tensor, 
+        min: float = None, 
+        max: float = None, 
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> torch.Tensor:
+    """Guard a tensor to a valid domain."""
+    x = torch.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = torch.clamp(x, min=min, max=max)
+    return x
+
+
+def replace_num(x: torch.Tensor, num: float, to: float) -> torch.Tensor:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (torch.Tensor): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        torch.Tensor: The tensor with the number replaced.
+    """
+    return torch.where(x == num, to, x)
+
+
+def guarded_torch_power(x: torch.Tensor, exp: float) -> torch.Tensor:
+    """Guard the power operation to a valid domain."""
+    return torch.pow(x, exp) if exp >= 1 else torch.pow(torch.relu(x), exp)
+
+
+def init_ones(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.ones_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_rand(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.randn_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_space_search(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    def _build_initial_param(tensor: torch.Tensor, max_initial: int, n_params: int):
+        """Generates the initial set of parameters. The first iteration generates 10 times more parameters."""
+        for _ in range(n_params * 10):  # The first iteration generates 10 times more parameters
+            yield init_rand(tensor) * max_initial  # Generates n_params in range [-max_initial, max_initial]
+
+    def _search_param(tensors: List[torch.tensor], n_params):
+        """Takes the best parameters and generates new parameters around the mean of the best parameters."""
+        torch_tensors = torch.stack(tensors)
+        min_vals, max_vals = torch.aminmax(torch_tensors, dim=0)
+        abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+        mean = torch.mean(torch_tensors, dim=0)
+        for _ in range(n_params):  # Generates n_params around the mean of the tensors
+            yield torch.randn_like(min_vals) * abs_max_val_per_ch + mean
+
+    def _calc(x, qtz_func, deqtz_func, **params):
+        x_ = x.transpose(0, 1)
+        x_ = qtz_func(x=x_, **params)
+        x_ = deqtz_func(x=x_, **params)
+        x_ = x_.transpose(0, 1)
+        return x_
+
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+    assert "deqtz_func" in kwargs, "deqtz_func must be provided."
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "param" in kwargs, "param must be provided."
+
+    qtz_func = kwargs.get('qtz_func')
+    deqtz_func = kwargs.get('deqtz_func')
+    params_list = kwargs.get('params_list')
+    param = kwargs.get('param')
+
+    n_runs = 50                # Number of runs to try to find the best parameters
+    n_random_params = 50       # Number of random parameters to generate
+    n_best_to_pick = 5         # Number of best parameters to pick after each run
+    max_initial = 10000        # Maximum value to initialize the parameters
+
+    # Initializes the parameters
+    base_params = { p: init_ones(x, **kwargs) for p in params_list if p != param }
+    params = _build_initial_param(x, max_initial, n_random_params)
+
+    # Performs the search
+    for _ in range(n_runs):
+        
+        best_params = []
+        for param_ in params:
+            try:
+                x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: param_})
+                loss_ones = nn.MSELoss()(x, x_)
+
+                if len(best_params) < n_best_to_pick:
+                    best_params.append((param_, loss_ones.item()))
+                    best_params = sorted(best_params, key=lambda x: x[1])
+                elif loss_ones < best_params[-1][1]:
+                    best_params[-1] = (param_, loss_ones.item())
+                    best_params = sorted(best_params, key=lambda x: x[1])
+
+            except Exception:  # The parameters might not be valid for the function's domain
+                continue
+
+        # Generates new parameters around the mean
+        params = _search_param([p for p, _ in best_params], n_random_params)
+
+    # Checks if the best parameter is better than the init_ones
+    p_ones = init_ones(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_ones})
+    loss_ones = nn.MSELoss()(x, x_)
+
+    # Checks if the best parameter is better than the init_rand
+    p_rand = init_rand(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_rand})
+    loss_rand = nn.MSELoss()(x, x_)
+
+    if loss_rand < best_params[0][1] and loss_rand < loss_ones:
+        return p_rand
+    elif loss_ones < best_params[0][1] and loss_ones < loss_rand:
+        return p_ones
+    else:
+        return best_params[0][0]
+
+
+def init_linear_scale(  # Symmetric scale. From the study folder
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+    assert "bits" in kwargs, "bits must be provided."
+    assert "params" in kwargs, "params must be provided."
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+
+    bits = kwargs.get('bits')
+    params = kwargs.get('params')
+    qtz_func = kwargs.get('qtz_func')
+
+    x_ = x.transpose(0, 1)
+    x_ = qtz_func(x=x_, **params, _s=init_ones(x, **kwargs))
+    x_ = x_.transpose(0, 1)
+    
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    min_vals, max_vals = torch.aminmax(x_, dim=1)
+    min_vals = torch.min(min_vals, torch.zeros_like(min_vals))
+    max_vals = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    eps = torch.finfo(torch.float32).eps
+
+    abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+    scale = abs_max_val_per_ch / (float(quant_max - quant_min) / 2)
+    
+    scale = torch.clamp(scale, min=eps).to(dtype=torch.float32, device=min_vals.device)
+
+    # Introduces some noise in scale
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything.
+    # NOTE(diogo): This has been disproven. The noise does not help the learning process but I still
+    # left it here for future reference. Will be removed later.
+    # scale = scale + 0.01 * torch.randn_like(scale)
+
+    return scale
+
+
+def init_non_linear_regression_fit(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "np_fit_func" in kwargs, "np_fit_func must be provided."
+    assert "p0" in kwargs, "p0 must be provided."
+    np_fit_func = kwargs.get('np_fit_func')
+    params_list = kwargs.get('params_list')
+    p0 = kwargs.get('p0')
+
+    def _fit(xdata: np.ndarray, ydata: np.ndarray, func: Callable, p0: List[float]):
+        popt, _ = curve_fit(
+            func, 
+            xdata, 
+            ydata, 
+            maxfev=1000,
+            p0=p0,
+            method='lm'
+        )
+        return popt
+
+    # 1. Needs to convert the torch tensor to numpy tensor
+    xdata = x.cpu().numpy()
+
+    # 2. Sorts the data so that it makes it easier to fit to it
+    sorted_xdata = np.sort(xdata, axis=-1)
+
+    p0 = {k: v.cpu().numpy() for k, v in p0.items()}
+    params_list = sorted(params_list)  # We need to make sure that it matches the numpy fit func arg order
+
+    # 3. Finds the best parameters for each channel
+    try:
+        params = []
+        for i in range(sorted_xdata.shape[0]):
+            xdata_ = sorted_xdata[i]
+            p0_ = [p0[p][i] for p in params_list]
+            ch_params = _fit(xdata_, xdata_, np_fit_func, p0_)
+            params.append(ch_params)
+
+        # 4. Builds the parameters
+        result = {}
+        for i, p in enumerate(params_list):
+            result[p] = torch.tensor([p_[i] for p_ in params], dtype=torch.float32).to(x.device)
+
+        return result
+
+    except ValueError as e:
+        print(f"Could not fit the function with error: {e}")
+        print(f"Using fallback result...")
+        return {
+            k: torch.tensor(v, dtype=torch.float32).to(x.device) for k, v in p0.items()
+        }
+
+
+def init_zeros(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.zeros_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_inner_scale(tensor: torch.Tensor, _min: float = torch.inf, _max: float = torch.inf) -> torch.Tensor:
+    # Calculate the original minimum and maximum values
+    min_vals, max_vals = torch.aminmax(tensor, dim=-1)
+    x_min = torch.min(min_vals, torch.zeros_like(min_vals))
+    x_max = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    if _max is torch.inf:  # We do not need to scale the tensor. Just need to move it
+        return torch.ones_like(x_min)
+    
+    # Calculate the scale factor
+    scale = (_max - _min) / (x_max - x_min)
+    return scale
+
+
+
+############## Quant ###############
+
+@torch.enable_grad()
+def learn_parameters(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    qtz_func: nn.Module,
+    deqtz_func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype,
+    epochs: int = 1000,
+    early_stop: bool = True,
+    do_report: bool = False
+) -> Tuple[Dict[str, nn.Parameter], torch.Tensor]:
+    loss_fn = nn.MSELoss()
+
+    # Determines the initial learning rate by computing the initial loss and multiplying it by
+    # the order of magnitude of the loss divided by 2
+    quant = quantize(x, params, qtz_func, bits, target_dtype)
+    dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+    loss = loss_fn(x, dequant)
+
+    base_lr = 0.1
+    exponent = int(np.floor(np.log10(loss.item())))
+    lr = base_lr * (10 ** (exponent // 2))
+    
+    # Requires gradients in the parameters
+    for p in params.values():
+        p.requires_grad = True
+        p.grad = None
+
+    param_keys = list(params.keys())
+    param_values = list(params.values())
+
+    # Defines optimizer and loss function
+    optimizer = torch.optim.Adam(param_values, lr=lr)
+
+    # Contains the best loss and the best parameters 
+    best_loss = float("inf")
+    best_params = None
+
+    # Used to stop the search early
+    min_delta = 1e-7
+    acc_loss = []
+    percent_epochs_before_stop = 0.1
+
+    for i in range(epochs):
+        optimizer.zero_grad()
+
+        quant = quantize(x, params, qtz_func, bits, target_dtype)
+        dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+        loss = loss_fn(x, dequant)
+
+        if loss.isnan() or loss.isinf():
+            raise Exception("Loss is NaN or Inf. Stopping the search.")
+
+        loss.backward()
+        optimizer.step()
+
+        acc_loss.append(loss.item())
+
+        # Reports loss every 10 steps
+        if i % 10 == 0 and do_report:
+            print(f"Epoch {i}: Loss {loss.item()}")
+
+        # Optimizes the parameter search by storing the best loss and the parameters
+        if loss.item() < best_loss:
+            best_loss = loss.item()
+            best_params = copy.deepcopy({
+                k: v for k, v in params.items() if k in param_keys
+            })
+
+        # We also stop the search if the loss has not considerably during the last 10% epochs
+        if early_stop:
+            epochs_before_stop = int(epochs * percent_epochs_before_stop)
+            if i > epochs_before_stop and abs(acc_loss[i - epochs_before_stop] - acc_loss[i]) < min_delta:
+                break
+
+    # No longer requires gradients in the parameters
+    for p in best_params.values():
+        p.requires_grad = False
+        p.grad = None
+    
+    if do_report:
+        print(f"Best loss: {best_loss}")
+        return best_params, acc_loss
+    else:
+        return best_params
+
+
+def quantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype = torch.int8
+) -> torch.Tensor:
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    x = x.transpose(0, 1)  # Aligns shapes
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    x = torch.clamp(round_func_BPDA(x), quant_min, quant_max).to(target_dtype)
+    return x
+
+
+def dequantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    out_dtype: torch.dtype
+) -> torch.Tensor:
+    x = x.to(dtype=out_dtype)
+    x = x.transpose(0, 1)
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    return x
+
+
+def round_func_BPDA(input):
+    # This is equivalent to replacing round function (non-differentiable) with
+    # an identity function (differentiable) only when backward.
+    forward_value = torch.round(input)
+    out = input.clone()
+    out.data = forward_value.data
+    return out
+
+
+def get_min_max_from_bits_signed(bit_width: int) -> Tuple[int, int]:
+    return -2 ** (bit_width - 1), 2 ** (bit_width - 1) - 1
+
+
+
+############## Numpy ###############
+
+def np_domain_guard(
+        x: np.ndarray,
+        min: float = None,
+        max: float = None,
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> np.ndarray:
+    """Guard a tensor to a valid domain."""
+    x = np.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = np.clip(x, min, max)
+    return x
+
+
+def np_replace_num(x: np.ndarray, num: float, to: float) -> np.ndarray:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (np.ndarray): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        np.ndarray: The tensor with the number replaced.
+    """
+    return np.where(x == num, to, x)
+
+
+def np_guarded_power(x: np.ndarray, exp: float) -> np.ndarray:
+    """Guard the power operation to a valid domain."""
+    return np.power(x, exp) if exp >= 1 else np.power(np.maximum(x, 0), exp)
+
diff --git a/fn_gen/nlr_t_no_sched/18/loss.png b/fn_gen/nlr_t_no_sched/18/loss.png
new file mode 100644
index 0000000000000000000000000000000000000000..dd0eb22fff8a69c0e58ac61560a304e5e30c3354
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/18/loss.png differ
diff --git a/fn_gen/nlr_t_no_sched/18/quantization.png b/fn_gen/nlr_t_no_sched/18/quantization.png
new file mode 100644
index 0000000000000000000000000000000000000000..b1f90fe5ac03fd4a01a4d90959b13b24bab559ca
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/18/quantization.png differ
diff --git a/fn_gen/nlr_t_no_sched/2/distortion.png b/fn_gen/nlr_t_no_sched/2/distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..8a3a8c03e297cee9c761d59764c3f7fb20b63554
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/2/distortion.png differ
diff --git a/fn_gen/nlr_t_no_sched/2/expressions.txt b/fn_gen/nlr_t_no_sched/2/expressions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..03413827fa8f4c8ad49a40b543460cf31d1ce803
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/2/expressions.txt
@@ -0,0 +1,2 @@
+asin(_0*x)/_s
+sin(_s*x)/_0
\ No newline at end of file
diff --git a/fn_gen/nlr_t_no_sched/2/fn.py b/fn_gen/nlr_t_no_sched/2/fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..25278331f126543740da25b2e9d8a0843796a6a3
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/2/fn.py
@@ -0,0 +1,479 @@
+from __future__ import annotations
+
+import torch
+from torch import amin  # Necessary for arcsin
+import copy
+import torch.nn as nn
+import numpy as np
+
+from scipy.optimize import curve_fit
+from typing import Dict, Any, Tuple, List, Callable
+
+
+def quantization(x, **params):
+	return (torch.div(1, replace_num(params['_s'], num=0, to=10000)) * torch.asin(domain_guard((params['_0'] * x), min=-0.99999, max=0.99999, nan=0)))
+
+
+def dequantization(x, **params):
+	return (torch.div(1, replace_num(params['_0'], num=0, to=10000)) * torch.sin((params['_s'] * x)))
+
+
+def init_params(x: torch.Tensor, **kwargs: Dict[str, Any]) -> Dict[str, nn.Parameter]:
+	base_p0 = {
+	'_0': init_space_search(x, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], param='_0', **kwargs),
+	}
+
+	base_p0['_s'] = init_linear_scale(x, qtz_func=quantization, params=base_p0, **kwargs)
+	if 'post_init_hook' in kwargs:
+		kwargs['post_init_hook'](parameters=base_p0)
+	
+	params = init_non_linear_regression_fit(x, p0=base_p0, np_fit_func=fit_func, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], **kwargs)
+	params = {k: nn.Parameter(v, requires_grad=False) for k, v in params.items()}
+	if 'post_method_hook' in kwargs:
+		kwargs['post_method_hook'](parameters=params)
+	
+	params = learn_parameters(x, params,
+		qtz_func=quantization,
+		deqtz_func=dequantization,
+		bits=kwargs['bits'],
+		target_dtype=torch.int8,
+		epochs=500,
+		early_stop=False,
+	)
+	if 'post_train_hook' in kwargs:
+		kwargs['post_train_hook'](parameters=params)
+	
+	return params
+
+
+############### Numpy Qtz ###############
+
+
+def np_quantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_s, num=0, to=10000)) * np.arcsin(np_domain_guard((_0 * x), min=-0.99999, max=0.99999, nan=0)))
+
+
+def np_dequantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_0, num=0, to=10000)) * np.sin((_s * x)))
+
+
+def fit_func(x, _0, _s):
+    x_ = np_quantization(x, _0, _s)
+    x_ = np_dequantization(x_, _0, _s)
+    return x_
+
+
+
+############### HELPERS ###############
+
+def domain_guard(
+        x: torch.Tensor, 
+        min: float = None, 
+        max: float = None, 
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> torch.Tensor:
+    """Guard a tensor to a valid domain."""
+    x = torch.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = torch.clamp(x, min=min, max=max)
+    return x
+
+
+def replace_num(x: torch.Tensor, num: float, to: float) -> torch.Tensor:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (torch.Tensor): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        torch.Tensor: The tensor with the number replaced.
+    """
+    return torch.where(x == num, to, x)
+
+
+def guarded_torch_power(x: torch.Tensor, exp: float) -> torch.Tensor:
+    """Guard the power operation to a valid domain."""
+    return torch.pow(x, exp) if exp >= 1 else torch.pow(torch.relu(x), exp)
+
+
+def init_ones(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.ones_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_rand(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.randn_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_space_search(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    def _build_initial_param(tensor: torch.Tensor, max_initial: int, n_params: int):
+        """Generates the initial set of parameters. The first iteration generates 10 times more parameters."""
+        for _ in range(n_params * 10):  # The first iteration generates 10 times more parameters
+            yield init_rand(tensor) * max_initial  # Generates n_params in range [-max_initial, max_initial]
+
+    def _search_param(tensors: List[torch.tensor], n_params):
+        """Takes the best parameters and generates new parameters around the mean of the best parameters."""
+        torch_tensors = torch.stack(tensors)
+        min_vals, max_vals = torch.aminmax(torch_tensors, dim=0)
+        abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+        mean = torch.mean(torch_tensors, dim=0)
+        for _ in range(n_params):  # Generates n_params around the mean of the tensors
+            yield torch.randn_like(min_vals) * abs_max_val_per_ch + mean
+
+    def _calc(x, qtz_func, deqtz_func, **params):
+        x_ = x.transpose(0, 1)
+        x_ = qtz_func(x=x_, **params)
+        x_ = deqtz_func(x=x_, **params)
+        x_ = x_.transpose(0, 1)
+        return x_
+
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+    assert "deqtz_func" in kwargs, "deqtz_func must be provided."
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "param" in kwargs, "param must be provided."
+
+    qtz_func = kwargs.get('qtz_func')
+    deqtz_func = kwargs.get('deqtz_func')
+    params_list = kwargs.get('params_list')
+    param = kwargs.get('param')
+
+    n_runs = 50                # Number of runs to try to find the best parameters
+    n_random_params = 50       # Number of random parameters to generate
+    n_best_to_pick = 5         # Number of best parameters to pick after each run
+    max_initial = 10000        # Maximum value to initialize the parameters
+
+    # Initializes the parameters
+    base_params = { p: init_ones(x, **kwargs) for p in params_list if p != param }
+    params = _build_initial_param(x, max_initial, n_random_params)
+
+    # Performs the search
+    for _ in range(n_runs):
+        
+        best_params = []
+        for param_ in params:
+            try:
+                x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: param_})
+                loss_ones = nn.MSELoss()(x, x_)
+
+                if len(best_params) < n_best_to_pick:
+                    best_params.append((param_, loss_ones.item()))
+                    best_params = sorted(best_params, key=lambda x: x[1])
+                elif loss_ones < best_params[-1][1]:
+                    best_params[-1] = (param_, loss_ones.item())
+                    best_params = sorted(best_params, key=lambda x: x[1])
+
+            except Exception:  # The parameters might not be valid for the function's domain
+                continue
+
+        # Generates new parameters around the mean
+        params = _search_param([p for p, _ in best_params], n_random_params)
+
+    # Checks if the best parameter is better than the init_ones
+    p_ones = init_ones(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_ones})
+    loss_ones = nn.MSELoss()(x, x_)
+
+    # Checks if the best parameter is better than the init_rand
+    p_rand = init_rand(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_rand})
+    loss_rand = nn.MSELoss()(x, x_)
+
+    if loss_rand < best_params[0][1] and loss_rand < loss_ones:
+        return p_rand
+    elif loss_ones < best_params[0][1] and loss_ones < loss_rand:
+        return p_ones
+    else:
+        return best_params[0][0]
+
+
+def init_linear_scale(  # Symmetric scale. From the study folder
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+    assert "bits" in kwargs, "bits must be provided."
+    assert "params" in kwargs, "params must be provided."
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+
+    bits = kwargs.get('bits')
+    params = kwargs.get('params')
+    qtz_func = kwargs.get('qtz_func')
+
+    x_ = x.transpose(0, 1)
+    x_ = qtz_func(x=x_, **params, _s=init_ones(x, **kwargs))
+    x_ = x_.transpose(0, 1)
+    
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    min_vals, max_vals = torch.aminmax(x_, dim=1)
+    min_vals = torch.min(min_vals, torch.zeros_like(min_vals))
+    max_vals = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    eps = torch.finfo(torch.float32).eps
+
+    abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+    scale = abs_max_val_per_ch / (float(quant_max - quant_min) / 2)
+    
+    scale = torch.clamp(scale, min=eps).to(dtype=torch.float32, device=min_vals.device)
+
+    # Introduces some noise in scale
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything.
+    # NOTE(diogo): This has been disproven. The noise does not help the learning process but I still
+    # left it here for future reference. Will be removed later.
+    # scale = scale + 0.01 * torch.randn_like(scale)
+
+    return scale
+
+
+def init_non_linear_regression_fit(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "np_fit_func" in kwargs, "np_fit_func must be provided."
+    assert "p0" in kwargs, "p0 must be provided."
+    np_fit_func = kwargs.get('np_fit_func')
+    params_list = kwargs.get('params_list')
+    p0 = kwargs.get('p0')
+
+    def _fit(xdata: np.ndarray, ydata: np.ndarray, func: Callable, p0: List[float]):
+        popt, _ = curve_fit(
+            func, 
+            xdata, 
+            ydata, 
+            maxfev=1000,
+            p0=p0,
+            method='lm'
+        )
+        return popt
+
+    # 1. Needs to convert the torch tensor to numpy tensor
+    xdata = x.cpu().numpy()
+
+    # 2. Sorts the data so that it makes it easier to fit to it
+    sorted_xdata = np.sort(xdata, axis=-1)
+
+    p0 = {k: v.cpu().numpy() for k, v in p0.items()}
+    params_list = sorted(params_list)  # We need to make sure that it matches the numpy fit func arg order
+
+    # 3. Finds the best parameters for each channel
+    try:
+        params = []
+        for i in range(sorted_xdata.shape[0]):
+            xdata_ = sorted_xdata[i]
+            p0_ = [p0[p][i] for p in params_list]
+            ch_params = _fit(xdata_, xdata_, np_fit_func, p0_)
+            params.append(ch_params)
+
+        # 4. Builds the parameters
+        result = {}
+        for i, p in enumerate(params_list):
+            result[p] = torch.tensor([p_[i] for p_ in params], dtype=torch.float32).to(x.device)
+
+        return result
+
+    except ValueError as e:
+        print(f"Could not fit the function with error: {e}")
+        print(f"Using fallback result...")
+        return {
+            k: torch.tensor(v, dtype=torch.float32).to(x.device) for k, v in p0.items()
+        }
+
+
+def init_zeros(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.zeros_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_inner_scale(tensor: torch.Tensor, _min: float = torch.inf, _max: float = torch.inf) -> torch.Tensor:
+    # Calculate the original minimum and maximum values
+    min_vals, max_vals = torch.aminmax(tensor, dim=-1)
+    x_min = torch.min(min_vals, torch.zeros_like(min_vals))
+    x_max = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    if _max is torch.inf:  # We do not need to scale the tensor. Just need to move it
+        return torch.ones_like(x_min)
+    
+    # Calculate the scale factor
+    scale = (_max - _min) / (x_max - x_min)
+    return scale
+
+
+
+############## Quant ###############
+
+@torch.enable_grad()
+def learn_parameters(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    qtz_func: nn.Module,
+    deqtz_func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype,
+    epochs: int = 1000,
+    early_stop: bool = True,
+    do_report: bool = False
+) -> Tuple[Dict[str, nn.Parameter], torch.Tensor]:
+    loss_fn = nn.MSELoss()
+
+    # Determines the initial learning rate by computing the initial loss and multiplying it by
+    # the order of magnitude of the loss divided by 2
+    quant = quantize(x, params, qtz_func, bits, target_dtype)
+    dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+    loss = loss_fn(x, dequant)
+
+    base_lr = 0.1
+    exponent = int(np.floor(np.log10(loss.item())))
+    lr = base_lr * (10 ** (exponent // 2))
+    
+    # Requires gradients in the parameters
+    for p in params.values():
+        p.requires_grad = True
+        p.grad = None
+
+    param_keys = list(params.keys())
+    param_values = list(params.values())
+
+    # Defines optimizer and loss function
+    optimizer = torch.optim.Adam(param_values, lr=lr)
+
+    # Contains the best loss and the best parameters 
+    best_loss = float("inf")
+    best_params = None
+
+    # Used to stop the search early
+    min_delta = 1e-7
+    acc_loss = []
+    percent_epochs_before_stop = 0.1
+
+    for i in range(epochs):
+        optimizer.zero_grad()
+
+        quant = quantize(x, params, qtz_func, bits, target_dtype)
+        dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+        loss = loss_fn(x, dequant)
+
+        if loss.isnan() or loss.isinf():
+            raise Exception("Loss is NaN or Inf. Stopping the search.")
+
+        loss.backward()
+        optimizer.step()
+
+        acc_loss.append(loss.item())
+
+        # Reports loss every 10 steps
+        if i % 10 == 0 and do_report:
+            print(f"Epoch {i}: Loss {loss.item()}")
+
+        # Optimizes the parameter search by storing the best loss and the parameters
+        if loss.item() < best_loss:
+            best_loss = loss.item()
+            best_params = copy.deepcopy({
+                k: v for k, v in params.items() if k in param_keys
+            })
+
+        # We also stop the search if the loss has not considerably during the last 10% epochs
+        if early_stop:
+            epochs_before_stop = int(epochs * percent_epochs_before_stop)
+            if i > epochs_before_stop and abs(acc_loss[i - epochs_before_stop] - acc_loss[i]) < min_delta:
+                break
+
+    # No longer requires gradients in the parameters
+    for p in best_params.values():
+        p.requires_grad = False
+        p.grad = None
+    
+    if do_report:
+        print(f"Best loss: {best_loss}")
+        return best_params, acc_loss
+    else:
+        return best_params
+
+
+def quantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype = torch.int8
+) -> torch.Tensor:
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    x = x.transpose(0, 1)  # Aligns shapes
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    x = torch.clamp(round_func_BPDA(x), quant_min, quant_max).to(target_dtype)
+    return x
+
+
+def dequantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    out_dtype: torch.dtype
+) -> torch.Tensor:
+    x = x.to(dtype=out_dtype)
+    x = x.transpose(0, 1)
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    return x
+
+
+def round_func_BPDA(input):
+    # This is equivalent to replacing round function (non-differentiable) with
+    # an identity function (differentiable) only when backward.
+    forward_value = torch.round(input)
+    out = input.clone()
+    out.data = forward_value.data
+    return out
+
+
+def get_min_max_from_bits_signed(bit_width: int) -> Tuple[int, int]:
+    return -2 ** (bit_width - 1), 2 ** (bit_width - 1) - 1
+
+
+
+############## Numpy ###############
+
+def np_domain_guard(
+        x: np.ndarray,
+        min: float = None,
+        max: float = None,
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> np.ndarray:
+    """Guard a tensor to a valid domain."""
+    x = np.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = np.clip(x, min, max)
+    return x
+
+
+def np_replace_num(x: np.ndarray, num: float, to: float) -> np.ndarray:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (np.ndarray): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        np.ndarray: The tensor with the number replaced.
+    """
+    return np.where(x == num, to, x)
+
+
+def np_guarded_power(x: np.ndarray, exp: float) -> np.ndarray:
+    """Guard the power operation to a valid domain."""
+    return np.power(x, exp) if exp >= 1 else np.power(np.maximum(x, 0), exp)
+
diff --git a/fn_gen/nlr_t_no_sched/2/loss.png b/fn_gen/nlr_t_no_sched/2/loss.png
new file mode 100644
index 0000000000000000000000000000000000000000..39f3b8be520e27f146b589fb5ddcc1440b1d8e53
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/2/loss.png differ
diff --git a/fn_gen/nlr_t_no_sched/2/quantization.png b/fn_gen/nlr_t_no_sched/2/quantization.png
new file mode 100644
index 0000000000000000000000000000000000000000..745741057f8368214962f9fb0a6db01f80a05313
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/2/quantization.png differ
diff --git a/fn_gen/nlr_t_no_sched/3/distortion.png b/fn_gen/nlr_t_no_sched/3/distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..a30a0f9e55602b86da4dfc29b1d937754e3b01b8
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/3/distortion.png differ
diff --git a/fn_gen/nlr_t_no_sched/3/expressions.txt b/fn_gen/nlr_t_no_sched/3/expressions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aa32b575e8c654dbc457c94f36222e70d86dc940
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/3/expressions.txt
@@ -0,0 +1,2 @@
+atan(_0*x)/_s
+tan(_s*x)/_0
\ No newline at end of file
diff --git a/fn_gen/nlr_t_no_sched/3/fn.py b/fn_gen/nlr_t_no_sched/3/fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..cd1e7e069d38525412252a2547f094cc2806e7aa
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/3/fn.py
@@ -0,0 +1,479 @@
+from __future__ import annotations
+
+import torch
+from torch import amin  # Necessary for arcsin
+import copy
+import torch.nn as nn
+import numpy as np
+
+from scipy.optimize import curve_fit
+from typing import Dict, Any, Tuple, List, Callable
+
+
+def quantization(x, **params):
+	return (torch.div(1, replace_num(params['_s'], num=0, to=10000)) * torch.atan((params['_0'] * x)))
+
+
+def dequantization(x, **params):
+	return (torch.div(1, replace_num(params['_0'], num=0, to=10000)) * torch.tan(domain_guard((params['_s'] * x), posinf=1, neginf=-1, nan=0)))
+
+
+def init_params(x: torch.Tensor, **kwargs: Dict[str, Any]) -> Dict[str, nn.Parameter]:
+	base_p0 = {
+	'_0': init_space_search(x, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], param='_0', **kwargs),
+	}
+
+	base_p0['_s'] = init_linear_scale(x, qtz_func=quantization, params=base_p0, **kwargs)
+	if 'post_init_hook' in kwargs:
+		kwargs['post_init_hook'](parameters=base_p0)
+	
+	params = init_non_linear_regression_fit(x, p0=base_p0, np_fit_func=fit_func, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], **kwargs)
+	params = {k: nn.Parameter(v, requires_grad=False) for k, v in params.items()}
+	if 'post_method_hook' in kwargs:
+		kwargs['post_method_hook'](parameters=params)
+	
+	params = learn_parameters(x, params,
+		qtz_func=quantization,
+		deqtz_func=dequantization,
+		bits=kwargs['bits'],
+		target_dtype=torch.int8,
+		epochs=500,
+		early_stop=False,
+	)
+	if 'post_train_hook' in kwargs:
+		kwargs['post_train_hook'](parameters=params)
+	
+	return params
+
+
+############### Numpy Qtz ###############
+
+
+def np_quantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_s, num=0, to=10000)) * np.arctan((_0 * x)))
+
+
+def np_dequantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_0, num=0, to=10000)) * np.tan(np_domain_guard((_s * x), posinf=1, neginf=-1, nan=0)))
+
+
+def fit_func(x, _0, _s):
+    x_ = np_quantization(x, _0, _s)
+    x_ = np_dequantization(x_, _0, _s)
+    return x_
+
+
+
+############### HELPERS ###############
+
+def domain_guard(
+        x: torch.Tensor, 
+        min: float = None, 
+        max: float = None, 
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> torch.Tensor:
+    """Guard a tensor to a valid domain."""
+    x = torch.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = torch.clamp(x, min=min, max=max)
+    return x
+
+
+def replace_num(x: torch.Tensor, num: float, to: float) -> torch.Tensor:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (torch.Tensor): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        torch.Tensor: The tensor with the number replaced.
+    """
+    return torch.where(x == num, to, x)
+
+
+def guarded_torch_power(x: torch.Tensor, exp: float) -> torch.Tensor:
+    """Guard the power operation to a valid domain."""
+    return torch.pow(x, exp) if exp >= 1 else torch.pow(torch.relu(x), exp)
+
+
+def init_ones(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.ones_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_rand(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.randn_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_space_search(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    def _build_initial_param(tensor: torch.Tensor, max_initial: int, n_params: int):
+        """Generates the initial set of parameters. The first iteration generates 10 times more parameters."""
+        for _ in range(n_params * 10):  # The first iteration generates 10 times more parameters
+            yield init_rand(tensor) * max_initial  # Generates n_params in range [-max_initial, max_initial]
+
+    def _search_param(tensors: List[torch.tensor], n_params):
+        """Takes the best parameters and generates new parameters around the mean of the best parameters."""
+        torch_tensors = torch.stack(tensors)
+        min_vals, max_vals = torch.aminmax(torch_tensors, dim=0)
+        abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+        mean = torch.mean(torch_tensors, dim=0)
+        for _ in range(n_params):  # Generates n_params around the mean of the tensors
+            yield torch.randn_like(min_vals) * abs_max_val_per_ch + mean
+
+    def _calc(x, qtz_func, deqtz_func, **params):
+        x_ = x.transpose(0, 1)
+        x_ = qtz_func(x=x_, **params)
+        x_ = deqtz_func(x=x_, **params)
+        x_ = x_.transpose(0, 1)
+        return x_
+
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+    assert "deqtz_func" in kwargs, "deqtz_func must be provided."
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "param" in kwargs, "param must be provided."
+
+    qtz_func = kwargs.get('qtz_func')
+    deqtz_func = kwargs.get('deqtz_func')
+    params_list = kwargs.get('params_list')
+    param = kwargs.get('param')
+
+    n_runs = 50                # Number of runs to try to find the best parameters
+    n_random_params = 50       # Number of random parameters to generate
+    n_best_to_pick = 5         # Number of best parameters to pick after each run
+    max_initial = 10000        # Maximum value to initialize the parameters
+
+    # Initializes the parameters
+    base_params = { p: init_ones(x, **kwargs) for p in params_list if p != param }
+    params = _build_initial_param(x, max_initial, n_random_params)
+
+    # Performs the search
+    for _ in range(n_runs):
+        
+        best_params = []
+        for param_ in params:
+            try:
+                x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: param_})
+                loss_ones = nn.MSELoss()(x, x_)
+
+                if len(best_params) < n_best_to_pick:
+                    best_params.append((param_, loss_ones.item()))
+                    best_params = sorted(best_params, key=lambda x: x[1])
+                elif loss_ones < best_params[-1][1]:
+                    best_params[-1] = (param_, loss_ones.item())
+                    best_params = sorted(best_params, key=lambda x: x[1])
+
+            except Exception:  # The parameters might not be valid for the function's domain
+                continue
+
+        # Generates new parameters around the mean
+        params = _search_param([p for p, _ in best_params], n_random_params)
+
+    # Checks if the best parameter is better than the init_ones
+    p_ones = init_ones(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_ones})
+    loss_ones = nn.MSELoss()(x, x_)
+
+    # Checks if the best parameter is better than the init_rand
+    p_rand = init_rand(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_rand})
+    loss_rand = nn.MSELoss()(x, x_)
+
+    if loss_rand < best_params[0][1] and loss_rand < loss_ones:
+        return p_rand
+    elif loss_ones < best_params[0][1] and loss_ones < loss_rand:
+        return p_ones
+    else:
+        return best_params[0][0]
+
+
+def init_linear_scale(  # Symmetric scale. From the study folder
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+    assert "bits" in kwargs, "bits must be provided."
+    assert "params" in kwargs, "params must be provided."
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+
+    bits = kwargs.get('bits')
+    params = kwargs.get('params')
+    qtz_func = kwargs.get('qtz_func')
+
+    x_ = x.transpose(0, 1)
+    x_ = qtz_func(x=x_, **params, _s=init_ones(x, **kwargs))
+    x_ = x_.transpose(0, 1)
+    
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    min_vals, max_vals = torch.aminmax(x_, dim=1)
+    min_vals = torch.min(min_vals, torch.zeros_like(min_vals))
+    max_vals = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    eps = torch.finfo(torch.float32).eps
+
+    abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+    scale = abs_max_val_per_ch / (float(quant_max - quant_min) / 2)
+    
+    scale = torch.clamp(scale, min=eps).to(dtype=torch.float32, device=min_vals.device)
+
+    # Introduces some noise in scale
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything.
+    # NOTE(diogo): This has been disproven. The noise does not help the learning process but I still
+    # left it here for future reference. Will be removed later.
+    # scale = scale + 0.01 * torch.randn_like(scale)
+
+    return scale
+
+
+def init_non_linear_regression_fit(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "np_fit_func" in kwargs, "np_fit_func must be provided."
+    assert "p0" in kwargs, "p0 must be provided."
+    np_fit_func = kwargs.get('np_fit_func')
+    params_list = kwargs.get('params_list')
+    p0 = kwargs.get('p0')
+
+    def _fit(xdata: np.ndarray, ydata: np.ndarray, func: Callable, p0: List[float]):
+        popt, _ = curve_fit(
+            func, 
+            xdata, 
+            ydata, 
+            maxfev=1000,
+            p0=p0,
+            method='lm'
+        )
+        return popt
+
+    # 1. Needs to convert the torch tensor to numpy tensor
+    xdata = x.cpu().numpy()
+
+    # 2. Sorts the data so that it makes it easier to fit to it
+    sorted_xdata = np.sort(xdata, axis=-1)
+
+    p0 = {k: v.cpu().numpy() for k, v in p0.items()}
+    params_list = sorted(params_list)  # We need to make sure that it matches the numpy fit func arg order
+
+    # 3. Finds the best parameters for each channel
+    try:
+        params = []
+        for i in range(sorted_xdata.shape[0]):
+            xdata_ = sorted_xdata[i]
+            p0_ = [p0[p][i] for p in params_list]
+            ch_params = _fit(xdata_, xdata_, np_fit_func, p0_)
+            params.append(ch_params)
+
+        # 4. Builds the parameters
+        result = {}
+        for i, p in enumerate(params_list):
+            result[p] = torch.tensor([p_[i] for p_ in params], dtype=torch.float32).to(x.device)
+
+        return result
+
+    except ValueError as e:
+        print(f"Could not fit the function with error: {e}")
+        print(f"Using fallback result...")
+        return {
+            k: torch.tensor(v, dtype=torch.float32).to(x.device) for k, v in p0.items()
+        }
+
+
+def init_zeros(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.zeros_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_inner_scale(tensor: torch.Tensor, _min: float = torch.inf, _max: float = torch.inf) -> torch.Tensor:
+    # Calculate the original minimum and maximum values
+    min_vals, max_vals = torch.aminmax(tensor, dim=-1)
+    x_min = torch.min(min_vals, torch.zeros_like(min_vals))
+    x_max = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    if _max is torch.inf:  # We do not need to scale the tensor. Just need to move it
+        return torch.ones_like(x_min)
+    
+    # Calculate the scale factor
+    scale = (_max - _min) / (x_max - x_min)
+    return scale
+
+
+
+############## Quant ###############
+
+@torch.enable_grad()
+def learn_parameters(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    qtz_func: nn.Module,
+    deqtz_func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype,
+    epochs: int = 1000,
+    early_stop: bool = True,
+    do_report: bool = False
+) -> Tuple[Dict[str, nn.Parameter], torch.Tensor]:
+    loss_fn = nn.MSELoss()
+
+    # Determines the initial learning rate by computing the initial loss and multiplying it by
+    # the order of magnitude of the loss divided by 2
+    quant = quantize(x, params, qtz_func, bits, target_dtype)
+    dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+    loss = loss_fn(x, dequant)
+
+    base_lr = 0.1
+    exponent = int(np.floor(np.log10(loss.item())))
+    lr = base_lr * (10 ** (exponent // 2))
+    
+    # Requires gradients in the parameters
+    for p in params.values():
+        p.requires_grad = True
+        p.grad = None
+
+    param_keys = list(params.keys())
+    param_values = list(params.values())
+
+    # Defines optimizer and loss function
+    optimizer = torch.optim.Adam(param_values, lr=lr)
+
+    # Contains the best loss and the best parameters 
+    best_loss = float("inf")
+    best_params = None
+
+    # Used to stop the search early
+    min_delta = 1e-7
+    acc_loss = []
+    percent_epochs_before_stop = 0.1
+
+    for i in range(epochs):
+        optimizer.zero_grad()
+
+        quant = quantize(x, params, qtz_func, bits, target_dtype)
+        dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+        loss = loss_fn(x, dequant)
+
+        if loss.isnan() or loss.isinf():
+            raise Exception("Loss is NaN or Inf. Stopping the search.")
+
+        loss.backward()
+        optimizer.step()
+
+        acc_loss.append(loss.item())
+
+        # Reports loss every 10 steps
+        if i % 10 == 0 and do_report:
+            print(f"Epoch {i}: Loss {loss.item()}")
+
+        # Optimizes the parameter search by storing the best loss and the parameters
+        if loss.item() < best_loss:
+            best_loss = loss.item()
+            best_params = copy.deepcopy({
+                k: v for k, v in params.items() if k in param_keys
+            })
+
+        # We also stop the search if the loss has not considerably during the last 10% epochs
+        if early_stop:
+            epochs_before_stop = int(epochs * percent_epochs_before_stop)
+            if i > epochs_before_stop and abs(acc_loss[i - epochs_before_stop] - acc_loss[i]) < min_delta:
+                break
+
+    # No longer requires gradients in the parameters
+    for p in best_params.values():
+        p.requires_grad = False
+        p.grad = None
+    
+    if do_report:
+        print(f"Best loss: {best_loss}")
+        return best_params, acc_loss
+    else:
+        return best_params
+
+
+def quantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype = torch.int8
+) -> torch.Tensor:
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    x = x.transpose(0, 1)  # Aligns shapes
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    x = torch.clamp(round_func_BPDA(x), quant_min, quant_max).to(target_dtype)
+    return x
+
+
+def dequantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    out_dtype: torch.dtype
+) -> torch.Tensor:
+    x = x.to(dtype=out_dtype)
+    x = x.transpose(0, 1)
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    return x
+
+
+def round_func_BPDA(input):
+    # This is equivalent to replacing round function (non-differentiable) with
+    # an identity function (differentiable) only when backward.
+    forward_value = torch.round(input)
+    out = input.clone()
+    out.data = forward_value.data
+    return out
+
+
+def get_min_max_from_bits_signed(bit_width: int) -> Tuple[int, int]:
+    return -2 ** (bit_width - 1), 2 ** (bit_width - 1) - 1
+
+
+
+############## Numpy ###############
+
+def np_domain_guard(
+        x: np.ndarray,
+        min: float = None,
+        max: float = None,
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> np.ndarray:
+    """Guard a tensor to a valid domain."""
+    x = np.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = np.clip(x, min, max)
+    return x
+
+
+def np_replace_num(x: np.ndarray, num: float, to: float) -> np.ndarray:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (np.ndarray): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        np.ndarray: The tensor with the number replaced.
+    """
+    return np.where(x == num, to, x)
+
+
+def np_guarded_power(x: np.ndarray, exp: float) -> np.ndarray:
+    """Guard the power operation to a valid domain."""
+    return np.power(x, exp) if exp >= 1 else np.power(np.maximum(x, 0), exp)
+
diff --git a/fn_gen/nlr_t_no_sched/3/loss.png b/fn_gen/nlr_t_no_sched/3/loss.png
new file mode 100644
index 0000000000000000000000000000000000000000..958458b7755ff7d4285c3748bd00859690fd281c
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/3/loss.png differ
diff --git a/fn_gen/nlr_t_no_sched/3/quantization.png b/fn_gen/nlr_t_no_sched/3/quantization.png
new file mode 100644
index 0000000000000000000000000000000000000000..21be31d564c5579858af7b3bc464eb0efcfc3257
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/3/quantization.png differ
diff --git a/fn_gen/nlr_t_no_sched/4/distortion.png b/fn_gen/nlr_t_no_sched/4/distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..5d9b24fc7fa3a342286b217ea711c2b8d756db41
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/4/distortion.png differ
diff --git a/fn_gen/nlr_t_no_sched/4/expressions.txt b/fn_gen/nlr_t_no_sched/4/expressions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ec55493201f7b2b8effaefed75e0a9258fc25c56
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/4/expressions.txt
@@ -0,0 +1,2 @@
+tanh(_0*x)/_s
+log((-_s*x - 1)/(_s*x - 1))/_0
\ No newline at end of file
diff --git a/fn_gen/nlr_t_no_sched/4/fn.py b/fn_gen/nlr_t_no_sched/4/fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0796934c77d3ddefeb86f95fc87781e0afb9bca
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/4/fn.py
@@ -0,0 +1,479 @@
+from __future__ import annotations
+
+import torch
+from torch import amin  # Necessary for arcsin
+import copy
+import torch.nn as nn
+import numpy as np
+
+from scipy.optimize import curve_fit
+from typing import Dict, Any, Tuple, List, Callable
+
+
+def quantization(x, **params):
+	return (torch.div(1, replace_num(params['_s'], num=0, to=10000)) * torch.tanh((params['_0'] * x)))
+
+
+def dequantization(x, **params):
+	return (torch.div(1, replace_num(params['_0'], num=0, to=10000)) * torch.log(domain_guard((torch.div(1, replace_num((torch.tensor(-1) + (params['_s'] * x)), num=0, to=10000)) * (torch.tensor(-1) + (torch.tensor(-1) * params['_s'] * x))), min=1e-5, nan=1e-5)))
+
+
+def init_params(x: torch.Tensor, **kwargs: Dict[str, Any]) -> Dict[str, nn.Parameter]:
+	base_p0 = {
+	'_0': init_space_search(x, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], param='_0', **kwargs),
+	}
+
+	base_p0['_s'] = init_linear_scale(x, qtz_func=quantization, params=base_p0, **kwargs)
+	if 'post_init_hook' in kwargs:
+		kwargs['post_init_hook'](parameters=base_p0)
+	
+	params = init_non_linear_regression_fit(x, p0=base_p0, np_fit_func=fit_func, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], **kwargs)
+	params = {k: nn.Parameter(v, requires_grad=False) for k, v in params.items()}
+	if 'post_method_hook' in kwargs:
+		kwargs['post_method_hook'](parameters=params)
+	
+	params = learn_parameters(x, params,
+		qtz_func=quantization,
+		deqtz_func=dequantization,
+		bits=kwargs['bits'],
+		target_dtype=torch.int8,
+		epochs=500,
+		early_stop=False,
+	)
+	if 'post_train_hook' in kwargs:
+		kwargs['post_train_hook'](parameters=params)
+	
+	return params
+
+
+############### Numpy Qtz ###############
+
+
+def np_quantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_s, num=0, to=10000)) * np.tanh((_0 * x)))
+
+
+def np_dequantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_0, num=0, to=10000)) * np.log(np_domain_guard((np.divide(1, np_replace_num((np.array(-1) + (_s * x)), num=0, to=10000)) * (np.array(-1) + (np.array(-1) * _s * x))), min=1e-5, nan=1e-5)))
+
+
+def fit_func(x, _0, _s):
+    x_ = np_quantization(x, _0, _s)
+    x_ = np_dequantization(x_, _0, _s)
+    return x_
+
+
+
+############### HELPERS ###############
+
+def domain_guard(
+        x: torch.Tensor, 
+        min: float = None, 
+        max: float = None, 
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> torch.Tensor:
+    """Guard a tensor to a valid domain."""
+    x = torch.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = torch.clamp(x, min=min, max=max)
+    return x
+
+
+def replace_num(x: torch.Tensor, num: float, to: float) -> torch.Tensor:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (torch.Tensor): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        torch.Tensor: The tensor with the number replaced.
+    """
+    return torch.where(x == num, to, x)
+
+
+def guarded_torch_power(x: torch.Tensor, exp: float) -> torch.Tensor:
+    """Guard the power operation to a valid domain."""
+    return torch.pow(x, exp) if exp >= 1 else torch.pow(torch.relu(x), exp)
+
+
+def init_ones(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.ones_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_rand(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.randn_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_space_search(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    def _build_initial_param(tensor: torch.Tensor, max_initial: int, n_params: int):
+        """Generates the initial set of parameters. The first iteration generates 10 times more parameters."""
+        for _ in range(n_params * 10):  # The first iteration generates 10 times more parameters
+            yield init_rand(tensor) * max_initial  # Generates n_params in range [-max_initial, max_initial]
+
+    def _search_param(tensors: List[torch.tensor], n_params):
+        """Takes the best parameters and generates new parameters around the mean of the best parameters."""
+        torch_tensors = torch.stack(tensors)
+        min_vals, max_vals = torch.aminmax(torch_tensors, dim=0)
+        abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+        mean = torch.mean(torch_tensors, dim=0)
+        for _ in range(n_params):  # Generates n_params around the mean of the tensors
+            yield torch.randn_like(min_vals) * abs_max_val_per_ch + mean
+
+    def _calc(x, qtz_func, deqtz_func, **params):
+        x_ = x.transpose(0, 1)
+        x_ = qtz_func(x=x_, **params)
+        x_ = deqtz_func(x=x_, **params)
+        x_ = x_.transpose(0, 1)
+        return x_
+
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+    assert "deqtz_func" in kwargs, "deqtz_func must be provided."
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "param" in kwargs, "param must be provided."
+
+    qtz_func = kwargs.get('qtz_func')
+    deqtz_func = kwargs.get('deqtz_func')
+    params_list = kwargs.get('params_list')
+    param = kwargs.get('param')
+
+    n_runs = 50                # Number of runs to try to find the best parameters
+    n_random_params = 50       # Number of random parameters to generate
+    n_best_to_pick = 5         # Number of best parameters to pick after each run
+    max_initial = 10000        # Maximum value to initialize the parameters
+
+    # Initializes the parameters
+    base_params = { p: init_ones(x, **kwargs) for p in params_list if p != param }
+    params = _build_initial_param(x, max_initial, n_random_params)
+
+    # Performs the search
+    for _ in range(n_runs):
+        
+        best_params = []
+        for param_ in params:
+            try:
+                x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: param_})
+                loss_ones = nn.MSELoss()(x, x_)
+
+                if len(best_params) < n_best_to_pick:
+                    best_params.append((param_, loss_ones.item()))
+                    best_params = sorted(best_params, key=lambda x: x[1])
+                elif loss_ones < best_params[-1][1]:
+                    best_params[-1] = (param_, loss_ones.item())
+                    best_params = sorted(best_params, key=lambda x: x[1])
+
+            except Exception:  # The parameters might not be valid for the function's domain
+                continue
+
+        # Generates new parameters around the mean
+        params = _search_param([p for p, _ in best_params], n_random_params)
+
+    # Checks if the best parameter is better than the init_ones
+    p_ones = init_ones(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_ones})
+    loss_ones = nn.MSELoss()(x, x_)
+
+    # Checks if the best parameter is better than the init_rand
+    p_rand = init_rand(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_rand})
+    loss_rand = nn.MSELoss()(x, x_)
+
+    if loss_rand < best_params[0][1] and loss_rand < loss_ones:
+        return p_rand
+    elif loss_ones < best_params[0][1] and loss_ones < loss_rand:
+        return p_ones
+    else:
+        return best_params[0][0]
+
+
+def init_linear_scale(  # Symmetric scale. From the study folder
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+    assert "bits" in kwargs, "bits must be provided."
+    assert "params" in kwargs, "params must be provided."
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+
+    bits = kwargs.get('bits')
+    params = kwargs.get('params')
+    qtz_func = kwargs.get('qtz_func')
+
+    x_ = x.transpose(0, 1)
+    x_ = qtz_func(x=x_, **params, _s=init_ones(x, **kwargs))
+    x_ = x_.transpose(0, 1)
+    
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    min_vals, max_vals = torch.aminmax(x_, dim=1)
+    min_vals = torch.min(min_vals, torch.zeros_like(min_vals))
+    max_vals = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    eps = torch.finfo(torch.float32).eps
+
+    abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+    scale = abs_max_val_per_ch / (float(quant_max - quant_min) / 2)
+    
+    scale = torch.clamp(scale, min=eps).to(dtype=torch.float32, device=min_vals.device)
+
+    # Introduces some noise in scale
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything.
+    # NOTE(diogo): This has been disproven. The noise does not help the learning process but I still
+    # left it here for future reference. Will be removed later.
+    # scale = scale + 0.01 * torch.randn_like(scale)
+
+    return scale
+
+
+def init_non_linear_regression_fit(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "np_fit_func" in kwargs, "np_fit_func must be provided."
+    assert "p0" in kwargs, "p0 must be provided."
+    np_fit_func = kwargs.get('np_fit_func')
+    params_list = kwargs.get('params_list')
+    p0 = kwargs.get('p0')
+
+    def _fit(xdata: np.ndarray, ydata: np.ndarray, func: Callable, p0: List[float]):
+        popt, _ = curve_fit(
+            func, 
+            xdata, 
+            ydata, 
+            maxfev=1000,
+            p0=p0,
+            method='lm'
+        )
+        return popt
+
+    # 1. Needs to convert the torch tensor to numpy tensor
+    xdata = x.cpu().numpy()
+
+    # 2. Sorts the data so that it makes it easier to fit to it
+    sorted_xdata = np.sort(xdata, axis=-1)
+
+    p0 = {k: v.cpu().numpy() for k, v in p0.items()}
+    params_list = sorted(params_list)  # We need to make sure that it matches the numpy fit func arg order
+
+    # 3. Finds the best parameters for each channel
+    try:
+        params = []
+        for i in range(sorted_xdata.shape[0]):
+            xdata_ = sorted_xdata[i]
+            p0_ = [p0[p][i] for p in params_list]
+            ch_params = _fit(xdata_, xdata_, np_fit_func, p0_)
+            params.append(ch_params)
+
+        # 4. Builds the parameters
+        result = {}
+        for i, p in enumerate(params_list):
+            result[p] = torch.tensor([p_[i] for p_ in params], dtype=torch.float32).to(x.device)
+
+        return result
+
+    except ValueError as e:
+        print(f"Could not fit the function with error: {e}")
+        print(f"Using fallback result...")
+        return {
+            k: torch.tensor(v, dtype=torch.float32).to(x.device) for k, v in p0.items()
+        }
+
+
+def init_zeros(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.zeros_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_inner_scale(tensor: torch.Tensor, _min: float = torch.inf, _max: float = torch.inf) -> torch.Tensor:
+    # Calculate the original minimum and maximum values
+    min_vals, max_vals = torch.aminmax(tensor, dim=-1)
+    x_min = torch.min(min_vals, torch.zeros_like(min_vals))
+    x_max = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    if _max is torch.inf:  # We do not need to scale the tensor. Just need to move it
+        return torch.ones_like(x_min)
+    
+    # Calculate the scale factor
+    scale = (_max - _min) / (x_max - x_min)
+    return scale
+
+
+
+############## Quant ###############
+
+@torch.enable_grad()
+def learn_parameters(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    qtz_func: nn.Module,
+    deqtz_func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype,
+    epochs: int = 1000,
+    early_stop: bool = True,
+    do_report: bool = False
+) -> Tuple[Dict[str, nn.Parameter], torch.Tensor]:
+    loss_fn = nn.MSELoss()
+
+    # Determines the initial learning rate by computing the initial loss and multiplying it by
+    # the order of magnitude of the loss divided by 2
+    quant = quantize(x, params, qtz_func, bits, target_dtype)
+    dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+    loss = loss_fn(x, dequant)
+
+    base_lr = 0.1
+    exponent = int(np.floor(np.log10(loss.item())))
+    lr = base_lr * (10 ** (exponent // 2))
+    
+    # Requires gradients in the parameters
+    for p in params.values():
+        p.requires_grad = True
+        p.grad = None
+
+    param_keys = list(params.keys())
+    param_values = list(params.values())
+
+    # Defines optimizer and loss function
+    optimizer = torch.optim.Adam(param_values, lr=lr)
+
+    # Contains the best loss and the best parameters 
+    best_loss = float("inf")
+    best_params = None
+
+    # Used to stop the search early
+    min_delta = 1e-7
+    acc_loss = []
+    percent_epochs_before_stop = 0.1
+
+    for i in range(epochs):
+        optimizer.zero_grad()
+
+        quant = quantize(x, params, qtz_func, bits, target_dtype)
+        dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+        loss = loss_fn(x, dequant)
+
+        if loss.isnan() or loss.isinf():
+            raise Exception("Loss is NaN or Inf. Stopping the search.")
+
+        loss.backward()
+        optimizer.step()
+
+        acc_loss.append(loss.item())
+
+        # Reports loss every 10 steps
+        if i % 10 == 0 and do_report:
+            print(f"Epoch {i}: Loss {loss.item()}")
+
+        # Optimizes the parameter search by storing the best loss and the parameters
+        if loss.item() < best_loss:
+            best_loss = loss.item()
+            best_params = copy.deepcopy({
+                k: v for k, v in params.items() if k in param_keys
+            })
+
+        # We also stop the search if the loss has not considerably during the last 10% epochs
+        if early_stop:
+            epochs_before_stop = int(epochs * percent_epochs_before_stop)
+            if i > epochs_before_stop and abs(acc_loss[i - epochs_before_stop] - acc_loss[i]) < min_delta:
+                break
+
+    # No longer requires gradients in the parameters
+    for p in best_params.values():
+        p.requires_grad = False
+        p.grad = None
+    
+    if do_report:
+        print(f"Best loss: {best_loss}")
+        return best_params, acc_loss
+    else:
+        return best_params
+
+
+def quantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype = torch.int8
+) -> torch.Tensor:
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    x = x.transpose(0, 1)  # Aligns shapes
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    x = torch.clamp(round_func_BPDA(x), quant_min, quant_max).to(target_dtype)
+    return x
+
+
+def dequantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    out_dtype: torch.dtype
+) -> torch.Tensor:
+    x = x.to(dtype=out_dtype)
+    x = x.transpose(0, 1)
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    return x
+
+
+def round_func_BPDA(input):
+    # This is equivalent to replacing round function (non-differentiable) with
+    # an identity function (differentiable) only when backward.
+    forward_value = torch.round(input)
+    out = input.clone()
+    out.data = forward_value.data
+    return out
+
+
+def get_min_max_from_bits_signed(bit_width: int) -> Tuple[int, int]:
+    return -2 ** (bit_width - 1), 2 ** (bit_width - 1) - 1
+
+
+
+############## Numpy ###############
+
+def np_domain_guard(
+        x: np.ndarray,
+        min: float = None,
+        max: float = None,
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> np.ndarray:
+    """Guard a tensor to a valid domain."""
+    x = np.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = np.clip(x, min, max)
+    return x
+
+
+def np_replace_num(x: np.ndarray, num: float, to: float) -> np.ndarray:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (np.ndarray): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        np.ndarray: The tensor with the number replaced.
+    """
+    return np.where(x == num, to, x)
+
+
+def np_guarded_power(x: np.ndarray, exp: float) -> np.ndarray:
+    """Guard the power operation to a valid domain."""
+    return np.power(x, exp) if exp >= 1 else np.power(np.maximum(x, 0), exp)
+
diff --git a/fn_gen/nlr_t_no_sched/4/loss.png b/fn_gen/nlr_t_no_sched/4/loss.png
new file mode 100644
index 0000000000000000000000000000000000000000..21e3b6adaffef8198a51c878a48baf085a5cf2c0
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/4/loss.png differ
diff --git a/fn_gen/nlr_t_no_sched/4/quantization.png b/fn_gen/nlr_t_no_sched/4/quantization.png
new file mode 100644
index 0000000000000000000000000000000000000000..f519e0d60d62a21c6ab6d27d74364ba9370ef0bd
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/4/quantization.png differ
diff --git a/fn_gen/nlr_t_no_sched/5/distortion.png b/fn_gen/nlr_t_no_sched/5/distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..01eebad0f56b3afc69a958d8ff03890fa0c585f9
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/5/distortion.png differ
diff --git a/fn_gen/nlr_t_no_sched/5/expressions.txt b/fn_gen/nlr_t_no_sched/5/expressions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..74791fc40576643d62f6366a8b4eda20eb1ad252
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/5/expressions.txt
@@ -0,0 +1,2 @@
+x**3/_s
+(_s*x)**(1/3)
\ No newline at end of file
diff --git a/fn_gen/nlr_t_no_sched/5/fn.py b/fn_gen/nlr_t_no_sched/5/fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..f9a69101786b79cb3d156eda0fa6c8113c3520ce
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/5/fn.py
@@ -0,0 +1,478 @@
+from __future__ import annotations
+
+import torch
+from torch import amin  # Necessary for arcsin
+import copy
+import torch.nn as nn
+import numpy as np
+
+from scipy.optimize import curve_fit
+from typing import Dict, Any, Tuple, List, Callable
+
+
+def quantization(x, **params):
+	return (torch.div(1, replace_num(params['_s'], num=0, to=10000)) * guarded_torch_power(x, torch.tensor(3)))
+
+
+def dequantization(x, **params):
+	return guarded_torch_power((params['_s'] * x), 1 / 3)
+
+
+def init_params(x: torch.Tensor, **kwargs: Dict[str, Any]) -> Dict[str, nn.Parameter]:
+	base_p0 = {
+	}
+
+	base_p0['_s'] = init_linear_scale(x, qtz_func=quantization, params=base_p0, **kwargs)
+	if 'post_init_hook' in kwargs:
+		kwargs['post_init_hook'](parameters=base_p0)
+	
+	params = init_non_linear_regression_fit(x, p0=base_p0, np_fit_func=fit_func, qtz_func=quantization, deqtz_func=dequantization, params_list=['_s'], **kwargs)
+	params = {k: nn.Parameter(v, requires_grad=False) for k, v in params.items()}
+	if 'post_method_hook' in kwargs:
+		kwargs['post_method_hook'](parameters=params)
+	
+	params = learn_parameters(x, params,
+		qtz_func=quantization,
+		deqtz_func=dequantization,
+		bits=kwargs['bits'],
+		target_dtype=torch.int8,
+		epochs=500,
+		early_stop=False,
+	)
+	if 'post_train_hook' in kwargs:
+		kwargs['post_train_hook'](parameters=params)
+	
+	return params
+
+
+############### Numpy Qtz ###############
+
+
+def np_quantization(x, _s):
+	return (np.divide(1, np_replace_num(_s, num=0, to=10000)) * np_guarded_power(x, np.array(3)))
+
+
+def np_dequantization(x, _s):
+	return np_guarded_power((_s * x), 1 / 3)
+
+
+def fit_func(x, _s):
+    x_ = np_quantization(x, _s)
+    x_ = np_dequantization(x_, _s)
+    return x_
+
+
+
+############### HELPERS ###############
+
+def domain_guard(
+        x: torch.Tensor, 
+        min: float = None, 
+        max: float = None, 
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> torch.Tensor:
+    """Guard a tensor to a valid domain."""
+    x = torch.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = torch.clamp(x, min=min, max=max)
+    return x
+
+
+def replace_num(x: torch.Tensor, num: float, to: float) -> torch.Tensor:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (torch.Tensor): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        torch.Tensor: The tensor with the number replaced.
+    """
+    return torch.where(x == num, to, x)
+
+
+def guarded_torch_power(x: torch.Tensor, exp: float) -> torch.Tensor:
+    """Guard the power operation to a valid domain."""
+    return torch.pow(x, exp) if exp >= 1 else torch.pow(torch.relu(x), exp)
+
+
+def init_ones(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.ones_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_rand(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.randn_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_space_search(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    def _build_initial_param(tensor: torch.Tensor, max_initial: int, n_params: int):
+        """Generates the initial set of parameters. The first iteration generates 10 times more parameters."""
+        for _ in range(n_params * 10):  # The first iteration generates 10 times more parameters
+            yield init_rand(tensor) * max_initial  # Generates n_params in range [-max_initial, max_initial]
+
+    def _search_param(tensors: List[torch.tensor], n_params):
+        """Takes the best parameters and generates new parameters around the mean of the best parameters."""
+        torch_tensors = torch.stack(tensors)
+        min_vals, max_vals = torch.aminmax(torch_tensors, dim=0)
+        abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+        mean = torch.mean(torch_tensors, dim=0)
+        for _ in range(n_params):  # Generates n_params around the mean of the tensors
+            yield torch.randn_like(min_vals) * abs_max_val_per_ch + mean
+
+    def _calc(x, qtz_func, deqtz_func, **params):
+        x_ = x.transpose(0, 1)
+        x_ = qtz_func(x=x_, **params)
+        x_ = deqtz_func(x=x_, **params)
+        x_ = x_.transpose(0, 1)
+        return x_
+
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+    assert "deqtz_func" in kwargs, "deqtz_func must be provided."
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "param" in kwargs, "param must be provided."
+
+    qtz_func = kwargs.get('qtz_func')
+    deqtz_func = kwargs.get('deqtz_func')
+    params_list = kwargs.get('params_list')
+    param = kwargs.get('param')
+
+    n_runs = 50                # Number of runs to try to find the best parameters
+    n_random_params = 50       # Number of random parameters to generate
+    n_best_to_pick = 5         # Number of best parameters to pick after each run
+    max_initial = 10000        # Maximum value to initialize the parameters
+
+    # Initializes the parameters
+    base_params = { p: init_ones(x, **kwargs) for p in params_list if p != param }
+    params = _build_initial_param(x, max_initial, n_random_params)
+
+    # Performs the search
+    for _ in range(n_runs):
+        
+        best_params = []
+        for param_ in params:
+            try:
+                x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: param_})
+                loss_ones = nn.MSELoss()(x, x_)
+
+                if len(best_params) < n_best_to_pick:
+                    best_params.append((param_, loss_ones.item()))
+                    best_params = sorted(best_params, key=lambda x: x[1])
+                elif loss_ones < best_params[-1][1]:
+                    best_params[-1] = (param_, loss_ones.item())
+                    best_params = sorted(best_params, key=lambda x: x[1])
+
+            except Exception:  # The parameters might not be valid for the function's domain
+                continue
+
+        # Generates new parameters around the mean
+        params = _search_param([p for p, _ in best_params], n_random_params)
+
+    # Checks if the best parameter is better than the init_ones
+    p_ones = init_ones(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_ones})
+    loss_ones = nn.MSELoss()(x, x_)
+
+    # Checks if the best parameter is better than the init_rand
+    p_rand = init_rand(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_rand})
+    loss_rand = nn.MSELoss()(x, x_)
+
+    if loss_rand < best_params[0][1] and loss_rand < loss_ones:
+        return p_rand
+    elif loss_ones < best_params[0][1] and loss_ones < loss_rand:
+        return p_ones
+    else:
+        return best_params[0][0]
+
+
+def init_linear_scale(  # Symmetric scale. From the study folder
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+    assert "bits" in kwargs, "bits must be provided."
+    assert "params" in kwargs, "params must be provided."
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+
+    bits = kwargs.get('bits')
+    params = kwargs.get('params')
+    qtz_func = kwargs.get('qtz_func')
+
+    x_ = x.transpose(0, 1)
+    x_ = qtz_func(x=x_, **params, _s=init_ones(x, **kwargs))
+    x_ = x_.transpose(0, 1)
+    
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    min_vals, max_vals = torch.aminmax(x_, dim=1)
+    min_vals = torch.min(min_vals, torch.zeros_like(min_vals))
+    max_vals = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    eps = torch.finfo(torch.float32).eps
+
+    abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+    scale = abs_max_val_per_ch / (float(quant_max - quant_min) / 2)
+    
+    scale = torch.clamp(scale, min=eps).to(dtype=torch.float32, device=min_vals.device)
+
+    # Introduces some noise in scale
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything.
+    # NOTE(diogo): This has been disproven. The noise does not help the learning process but I still
+    # left it here for future reference. Will be removed later.
+    # scale = scale + 0.01 * torch.randn_like(scale)
+
+    return scale
+
+
+def init_non_linear_regression_fit(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "np_fit_func" in kwargs, "np_fit_func must be provided."
+    assert "p0" in kwargs, "p0 must be provided."
+    np_fit_func = kwargs.get('np_fit_func')
+    params_list = kwargs.get('params_list')
+    p0 = kwargs.get('p0')
+
+    def _fit(xdata: np.ndarray, ydata: np.ndarray, func: Callable, p0: List[float]):
+        popt, _ = curve_fit(
+            func, 
+            xdata, 
+            ydata, 
+            maxfev=1000,
+            p0=p0,
+            method='lm'
+        )
+        return popt
+
+    # 1. Needs to convert the torch tensor to numpy tensor
+    xdata = x.cpu().numpy()
+
+    # 2. Sorts the data so that it makes it easier to fit to it
+    sorted_xdata = np.sort(xdata, axis=-1)
+
+    p0 = {k: v.cpu().numpy() for k, v in p0.items()}
+    params_list = sorted(params_list)  # We need to make sure that it matches the numpy fit func arg order
+
+    # 3. Finds the best parameters for each channel
+    try:
+        params = []
+        for i in range(sorted_xdata.shape[0]):
+            xdata_ = sorted_xdata[i]
+            p0_ = [p0[p][i] for p in params_list]
+            ch_params = _fit(xdata_, xdata_, np_fit_func, p0_)
+            params.append(ch_params)
+
+        # 4. Builds the parameters
+        result = {}
+        for i, p in enumerate(params_list):
+            result[p] = torch.tensor([p_[i] for p_ in params], dtype=torch.float32).to(x.device)
+
+        return result
+
+    except ValueError as e:
+        print(f"Could not fit the function with error: {e}")
+        print(f"Using fallback result...")
+        return {
+            k: torch.tensor(v, dtype=torch.float32).to(x.device) for k, v in p0.items()
+        }
+
+
+def init_zeros(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.zeros_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_inner_scale(tensor: torch.Tensor, _min: float = torch.inf, _max: float = torch.inf) -> torch.Tensor:
+    # Calculate the original minimum and maximum values
+    min_vals, max_vals = torch.aminmax(tensor, dim=-1)
+    x_min = torch.min(min_vals, torch.zeros_like(min_vals))
+    x_max = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    if _max is torch.inf:  # We do not need to scale the tensor. Just need to move it
+        return torch.ones_like(x_min)
+    
+    # Calculate the scale factor
+    scale = (_max - _min) / (x_max - x_min)
+    return scale
+
+
+
+############## Quant ###############
+
+@torch.enable_grad()
+def learn_parameters(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    qtz_func: nn.Module,
+    deqtz_func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype,
+    epochs: int = 1000,
+    early_stop: bool = True,
+    do_report: bool = False
+) -> Tuple[Dict[str, nn.Parameter], torch.Tensor]:
+    loss_fn = nn.MSELoss()
+
+    # Determines the initial learning rate by computing the initial loss and multiplying it by
+    # the order of magnitude of the loss divided by 2
+    quant = quantize(x, params, qtz_func, bits, target_dtype)
+    dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+    loss = loss_fn(x, dequant)
+
+    base_lr = 0.1
+    exponent = int(np.floor(np.log10(loss.item())))
+    lr = base_lr * (10 ** (exponent // 2))
+    
+    # Requires gradients in the parameters
+    for p in params.values():
+        p.requires_grad = True
+        p.grad = None
+
+    param_keys = list(params.keys())
+    param_values = list(params.values())
+
+    # Defines optimizer and loss function
+    optimizer = torch.optim.Adam(param_values, lr=lr)
+
+    # Contains the best loss and the best parameters 
+    best_loss = float("inf")
+    best_params = None
+
+    # Used to stop the search early
+    min_delta = 1e-7
+    acc_loss = []
+    percent_epochs_before_stop = 0.1
+
+    for i in range(epochs):
+        optimizer.zero_grad()
+
+        quant = quantize(x, params, qtz_func, bits, target_dtype)
+        dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+        loss = loss_fn(x, dequant)
+
+        if loss.isnan() or loss.isinf():
+            raise Exception("Loss is NaN or Inf. Stopping the search.")
+
+        loss.backward()
+        optimizer.step()
+
+        acc_loss.append(loss.item())
+
+        # Reports loss every 10 steps
+        if i % 10 == 0 and do_report:
+            print(f"Epoch {i}: Loss {loss.item()}")
+
+        # Optimizes the parameter search by storing the best loss and the parameters
+        if loss.item() < best_loss:
+            best_loss = loss.item()
+            best_params = copy.deepcopy({
+                k: v for k, v in params.items() if k in param_keys
+            })
+
+        # We also stop the search if the loss has not considerably during the last 10% epochs
+        if early_stop:
+            epochs_before_stop = int(epochs * percent_epochs_before_stop)
+            if i > epochs_before_stop and abs(acc_loss[i - epochs_before_stop] - acc_loss[i]) < min_delta:
+                break
+
+    # No longer requires gradients in the parameters
+    for p in best_params.values():
+        p.requires_grad = False
+        p.grad = None
+    
+    if do_report:
+        print(f"Best loss: {best_loss}")
+        return best_params, acc_loss
+    else:
+        return best_params
+
+
+def quantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype = torch.int8
+) -> torch.Tensor:
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    x = x.transpose(0, 1)  # Aligns shapes
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    x = torch.clamp(round_func_BPDA(x), quant_min, quant_max).to(target_dtype)
+    return x
+
+
+def dequantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    out_dtype: torch.dtype
+) -> torch.Tensor:
+    x = x.to(dtype=out_dtype)
+    x = x.transpose(0, 1)
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    return x
+
+
+def round_func_BPDA(input):
+    # This is equivalent to replacing round function (non-differentiable) with
+    # an identity function (differentiable) only when backward.
+    forward_value = torch.round(input)
+    out = input.clone()
+    out.data = forward_value.data
+    return out
+
+
+def get_min_max_from_bits_signed(bit_width: int) -> Tuple[int, int]:
+    return -2 ** (bit_width - 1), 2 ** (bit_width - 1) - 1
+
+
+
+############## Numpy ###############
+
+def np_domain_guard(
+        x: np.ndarray,
+        min: float = None,
+        max: float = None,
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> np.ndarray:
+    """Guard a tensor to a valid domain."""
+    x = np.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = np.clip(x, min, max)
+    return x
+
+
+def np_replace_num(x: np.ndarray, num: float, to: float) -> np.ndarray:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (np.ndarray): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        np.ndarray: The tensor with the number replaced.
+    """
+    return np.where(x == num, to, x)
+
+
+def np_guarded_power(x: np.ndarray, exp: float) -> np.ndarray:
+    """Guard the power operation to a valid domain."""
+    return np.power(x, exp) if exp >= 1 else np.power(np.maximum(x, 0), exp)
+
diff --git a/fn_gen/nlr_t_no_sched/5/loss.png b/fn_gen/nlr_t_no_sched/5/loss.png
new file mode 100644
index 0000000000000000000000000000000000000000..d87c4001adff7eca3e38a84e506d79eeb2dcf382
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/5/loss.png differ
diff --git a/fn_gen/nlr_t_no_sched/5/quantization.png b/fn_gen/nlr_t_no_sched/5/quantization.png
new file mode 100644
index 0000000000000000000000000000000000000000..fd4327ed08a7d5b12be2ab02a630004db222515c
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/5/quantization.png differ
diff --git a/fn_gen/nlr_t_no_sched/6/distortion.png b/fn_gen/nlr_t_no_sched/6/distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..22c3f6cde875ca017106cdbf1b72a9652fca95f5
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/6/distortion.png differ
diff --git a/fn_gen/nlr_t_no_sched/6/expressions.txt b/fn_gen/nlr_t_no_sched/6/expressions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c7b68c388fdf6e1b6e2be8076f1d4b8d7bcef4f9
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/6/expressions.txt
@@ -0,0 +1,2 @@
+(_0*x)**(1/3)/_s
+_s**3*x**3/_0
\ No newline at end of file
diff --git a/fn_gen/nlr_t_no_sched/6/fn.py b/fn_gen/nlr_t_no_sched/6/fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..e07d5fb6461f525dff1abf3ce01b4a493d8bd659
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/6/fn.py
@@ -0,0 +1,479 @@
+from __future__ import annotations
+
+import torch
+from torch import amin  # Necessary for arcsin
+import copy
+import torch.nn as nn
+import numpy as np
+
+from scipy.optimize import curve_fit
+from typing import Dict, Any, Tuple, List, Callable
+
+
+def quantization(x, **params):
+	return (torch.div(1, replace_num(params['_s'], num=0, to=10000)) * guarded_torch_power((params['_0'] * x), 1 / 3))
+
+
+def dequantization(x, **params):
+	return (torch.div(1, replace_num(params['_0'], num=0, to=10000)) * guarded_torch_power(params['_s'], torch.tensor(3)) * guarded_torch_power(x, torch.tensor(3)))
+
+
+def init_params(x: torch.Tensor, **kwargs: Dict[str, Any]) -> Dict[str, nn.Parameter]:
+	base_p0 = {
+	'_0': init_space_search(x, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], param='_0', **kwargs),
+	}
+
+	base_p0['_s'] = init_linear_scale(x, qtz_func=quantization, params=base_p0, **kwargs)
+	if 'post_init_hook' in kwargs:
+		kwargs['post_init_hook'](parameters=base_p0)
+	
+	params = init_non_linear_regression_fit(x, p0=base_p0, np_fit_func=fit_func, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], **kwargs)
+	params = {k: nn.Parameter(v, requires_grad=False) for k, v in params.items()}
+	if 'post_method_hook' in kwargs:
+		kwargs['post_method_hook'](parameters=params)
+	
+	params = learn_parameters(x, params,
+		qtz_func=quantization,
+		deqtz_func=dequantization,
+		bits=kwargs['bits'],
+		target_dtype=torch.int8,
+		epochs=500,
+		early_stop=False,
+	)
+	if 'post_train_hook' in kwargs:
+		kwargs['post_train_hook'](parameters=params)
+	
+	return params
+
+
+############### Numpy Qtz ###############
+
+
+def np_quantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_s, num=0, to=10000)) * np_guarded_power((_0 * x), 1 / 3))
+
+
+def np_dequantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_0, num=0, to=10000)) * np_guarded_power(_s, np.array(3)) * np_guarded_power(x, np.array(3)))
+
+
+def fit_func(x, _0, _s):
+    x_ = np_quantization(x, _0, _s)
+    x_ = np_dequantization(x_, _0, _s)
+    return x_
+
+
+
+############### HELPERS ###############
+
+def domain_guard(
+        x: torch.Tensor, 
+        min: float = None, 
+        max: float = None, 
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> torch.Tensor:
+    """Guard a tensor to a valid domain."""
+    x = torch.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = torch.clamp(x, min=min, max=max)
+    return x
+
+
+def replace_num(x: torch.Tensor, num: float, to: float) -> torch.Tensor:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (torch.Tensor): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        torch.Tensor: The tensor with the number replaced.
+    """
+    return torch.where(x == num, to, x)
+
+
+def guarded_torch_power(x: torch.Tensor, exp: float) -> torch.Tensor:
+    """Guard the power operation to a valid domain."""
+    return torch.pow(x, exp) if exp >= 1 else torch.pow(torch.relu(x), exp)
+
+
+def init_ones(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.ones_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_rand(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.randn_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_space_search(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    def _build_initial_param(tensor: torch.Tensor, max_initial: int, n_params: int):
+        """Generates the initial set of parameters. The first iteration generates 10 times more parameters."""
+        for _ in range(n_params * 10):  # The first iteration generates 10 times more parameters
+            yield init_rand(tensor) * max_initial  # Generates n_params in range [-max_initial, max_initial]
+
+    def _search_param(tensors: List[torch.tensor], n_params):
+        """Takes the best parameters and generates new parameters around the mean of the best parameters."""
+        torch_tensors = torch.stack(tensors)
+        min_vals, max_vals = torch.aminmax(torch_tensors, dim=0)
+        abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+        mean = torch.mean(torch_tensors, dim=0)
+        for _ in range(n_params):  # Generates n_params around the mean of the tensors
+            yield torch.randn_like(min_vals) * abs_max_val_per_ch + mean
+
+    def _calc(x, qtz_func, deqtz_func, **params):
+        x_ = x.transpose(0, 1)
+        x_ = qtz_func(x=x_, **params)
+        x_ = deqtz_func(x=x_, **params)
+        x_ = x_.transpose(0, 1)
+        return x_
+
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+    assert "deqtz_func" in kwargs, "deqtz_func must be provided."
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "param" in kwargs, "param must be provided."
+
+    qtz_func = kwargs.get('qtz_func')
+    deqtz_func = kwargs.get('deqtz_func')
+    params_list = kwargs.get('params_list')
+    param = kwargs.get('param')
+
+    n_runs = 50                # Number of runs to try to find the best parameters
+    n_random_params = 50       # Number of random parameters to generate
+    n_best_to_pick = 5         # Number of best parameters to pick after each run
+    max_initial = 10000        # Maximum value to initialize the parameters
+
+    # Initializes the parameters
+    base_params = { p: init_ones(x, **kwargs) for p in params_list if p != param }
+    params = _build_initial_param(x, max_initial, n_random_params)
+
+    # Performs the search
+    for _ in range(n_runs):
+        
+        best_params = []
+        for param_ in params:
+            try:
+                x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: param_})
+                loss_ones = nn.MSELoss()(x, x_)
+
+                if len(best_params) < n_best_to_pick:
+                    best_params.append((param_, loss_ones.item()))
+                    best_params = sorted(best_params, key=lambda x: x[1])
+                elif loss_ones < best_params[-1][1]:
+                    best_params[-1] = (param_, loss_ones.item())
+                    best_params = sorted(best_params, key=lambda x: x[1])
+
+            except Exception:  # The parameters might not be valid for the function's domain
+                continue
+
+        # Generates new parameters around the mean
+        params = _search_param([p for p, _ in best_params], n_random_params)
+
+    # Checks if the best parameter is better than the init_ones
+    p_ones = init_ones(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_ones})
+    loss_ones = nn.MSELoss()(x, x_)
+
+    # Checks if the best parameter is better than the init_rand
+    p_rand = init_rand(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_rand})
+    loss_rand = nn.MSELoss()(x, x_)
+
+    if loss_rand < best_params[0][1] and loss_rand < loss_ones:
+        return p_rand
+    elif loss_ones < best_params[0][1] and loss_ones < loss_rand:
+        return p_ones
+    else:
+        return best_params[0][0]
+
+
+def init_linear_scale(  # Symmetric scale. From the study folder
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+    assert "bits" in kwargs, "bits must be provided."
+    assert "params" in kwargs, "params must be provided."
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+
+    bits = kwargs.get('bits')
+    params = kwargs.get('params')
+    qtz_func = kwargs.get('qtz_func')
+
+    x_ = x.transpose(0, 1)
+    x_ = qtz_func(x=x_, **params, _s=init_ones(x, **kwargs))
+    x_ = x_.transpose(0, 1)
+    
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    min_vals, max_vals = torch.aminmax(x_, dim=1)
+    min_vals = torch.min(min_vals, torch.zeros_like(min_vals))
+    max_vals = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    eps = torch.finfo(torch.float32).eps
+
+    abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+    scale = abs_max_val_per_ch / (float(quant_max - quant_min) / 2)
+    
+    scale = torch.clamp(scale, min=eps).to(dtype=torch.float32, device=min_vals.device)
+
+    # Introduces some noise in scale
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything.
+    # NOTE(diogo): This has been disproven. The noise does not help the learning process but I still
+    # left it here for future reference. Will be removed later.
+    # scale = scale + 0.01 * torch.randn_like(scale)
+
+    return scale
+
+
+def init_non_linear_regression_fit(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "np_fit_func" in kwargs, "np_fit_func must be provided."
+    assert "p0" in kwargs, "p0 must be provided."
+    np_fit_func = kwargs.get('np_fit_func')
+    params_list = kwargs.get('params_list')
+    p0 = kwargs.get('p0')
+
+    def _fit(xdata: np.ndarray, ydata: np.ndarray, func: Callable, p0: List[float]):
+        popt, _ = curve_fit(
+            func, 
+            xdata, 
+            ydata, 
+            maxfev=1000,
+            p0=p0,
+            method='lm'
+        )
+        return popt
+
+    # 1. Needs to convert the torch tensor to numpy tensor
+    xdata = x.cpu().numpy()
+
+    # 2. Sorts the data so that it makes it easier to fit to it
+    sorted_xdata = np.sort(xdata, axis=-1)
+
+    p0 = {k: v.cpu().numpy() for k, v in p0.items()}
+    params_list = sorted(params_list)  # We need to make sure that it matches the numpy fit func arg order
+
+    # 3. Finds the best parameters for each channel
+    try:
+        params = []
+        for i in range(sorted_xdata.shape[0]):
+            xdata_ = sorted_xdata[i]
+            p0_ = [p0[p][i] for p in params_list]
+            ch_params = _fit(xdata_, xdata_, np_fit_func, p0_)
+            params.append(ch_params)
+
+        # 4. Builds the parameters
+        result = {}
+        for i, p in enumerate(params_list):
+            result[p] = torch.tensor([p_[i] for p_ in params], dtype=torch.float32).to(x.device)
+
+        return result
+
+    except ValueError as e:
+        print(f"Could not fit the function with error: {e}")
+        print(f"Using fallback result...")
+        return {
+            k: torch.tensor(v, dtype=torch.float32).to(x.device) for k, v in p0.items()
+        }
+
+
+def init_zeros(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.zeros_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_inner_scale(tensor: torch.Tensor, _min: float = torch.inf, _max: float = torch.inf) -> torch.Tensor:
+    # Calculate the original minimum and maximum values
+    min_vals, max_vals = torch.aminmax(tensor, dim=-1)
+    x_min = torch.min(min_vals, torch.zeros_like(min_vals))
+    x_max = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    if _max is torch.inf:  # We do not need to scale the tensor. Just need to move it
+        return torch.ones_like(x_min)
+    
+    # Calculate the scale factor
+    scale = (_max - _min) / (x_max - x_min)
+    return scale
+
+
+
+############## Quant ###############
+
+@torch.enable_grad()
+def learn_parameters(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    qtz_func: nn.Module,
+    deqtz_func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype,
+    epochs: int = 1000,
+    early_stop: bool = True,
+    do_report: bool = False
+) -> Tuple[Dict[str, nn.Parameter], torch.Tensor]:
+    loss_fn = nn.MSELoss()
+
+    # Determines the initial learning rate by computing the initial loss and multiplying it by
+    # the order of magnitude of the loss divided by 2
+    quant = quantize(x, params, qtz_func, bits, target_dtype)
+    dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+    loss = loss_fn(x, dequant)
+
+    base_lr = 0.1
+    exponent = int(np.floor(np.log10(loss.item())))
+    lr = base_lr * (10 ** (exponent // 2))
+    
+    # Requires gradients in the parameters
+    for p in params.values():
+        p.requires_grad = True
+        p.grad = None
+
+    param_keys = list(params.keys())
+    param_values = list(params.values())
+
+    # Defines optimizer and loss function
+    optimizer = torch.optim.Adam(param_values, lr=lr)
+
+    # Contains the best loss and the best parameters 
+    best_loss = float("inf")
+    best_params = None
+
+    # Used to stop the search early
+    min_delta = 1e-7
+    acc_loss = []
+    percent_epochs_before_stop = 0.1
+
+    for i in range(epochs):
+        optimizer.zero_grad()
+
+        quant = quantize(x, params, qtz_func, bits, target_dtype)
+        dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+        loss = loss_fn(x, dequant)
+
+        if loss.isnan() or loss.isinf():
+            raise Exception("Loss is NaN or Inf. Stopping the search.")
+
+        loss.backward()
+        optimizer.step()
+
+        acc_loss.append(loss.item())
+
+        # Reports loss every 10 steps
+        if i % 10 == 0 and do_report:
+            print(f"Epoch {i}: Loss {loss.item()}")
+
+        # Optimizes the parameter search by storing the best loss and the parameters
+        if loss.item() < best_loss:
+            best_loss = loss.item()
+            best_params = copy.deepcopy({
+                k: v for k, v in params.items() if k in param_keys
+            })
+
+        # We also stop the search if the loss has not considerably during the last 10% epochs
+        if early_stop:
+            epochs_before_stop = int(epochs * percent_epochs_before_stop)
+            if i > epochs_before_stop and abs(acc_loss[i - epochs_before_stop] - acc_loss[i]) < min_delta:
+                break
+
+    # No longer requires gradients in the parameters
+    for p in best_params.values():
+        p.requires_grad = False
+        p.grad = None
+    
+    if do_report:
+        print(f"Best loss: {best_loss}")
+        return best_params, acc_loss
+    else:
+        return best_params
+
+
+def quantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype = torch.int8
+) -> torch.Tensor:
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    x = x.transpose(0, 1)  # Aligns shapes
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    x = torch.clamp(round_func_BPDA(x), quant_min, quant_max).to(target_dtype)
+    return x
+
+
+def dequantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    out_dtype: torch.dtype
+) -> torch.Tensor:
+    x = x.to(dtype=out_dtype)
+    x = x.transpose(0, 1)
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    return x
+
+
+def round_func_BPDA(input):
+    # This is equivalent to replacing round function (non-differentiable) with
+    # an identity function (differentiable) only when backward.
+    forward_value = torch.round(input)
+    out = input.clone()
+    out.data = forward_value.data
+    return out
+
+
+def get_min_max_from_bits_signed(bit_width: int) -> Tuple[int, int]:
+    return -2 ** (bit_width - 1), 2 ** (bit_width - 1) - 1
+
+
+
+############## Numpy ###############
+
+def np_domain_guard(
+        x: np.ndarray,
+        min: float = None,
+        max: float = None,
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> np.ndarray:
+    """Guard a tensor to a valid domain."""
+    x = np.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = np.clip(x, min, max)
+    return x
+
+
+def np_replace_num(x: np.ndarray, num: float, to: float) -> np.ndarray:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (np.ndarray): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        np.ndarray: The tensor with the number replaced.
+    """
+    return np.where(x == num, to, x)
+
+
+def np_guarded_power(x: np.ndarray, exp: float) -> np.ndarray:
+    """Guard the power operation to a valid domain."""
+    return np.power(x, exp) if exp >= 1 else np.power(np.maximum(x, 0), exp)
+
diff --git a/fn_gen/nlr_t_no_sched/6/loss.png b/fn_gen/nlr_t_no_sched/6/loss.png
new file mode 100644
index 0000000000000000000000000000000000000000..9535f1ba7daa2f25bdf83935fc433741462104df
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/6/loss.png differ
diff --git a/fn_gen/nlr_t_no_sched/6/quantization.png b/fn_gen/nlr_t_no_sched/6/quantization.png
new file mode 100644
index 0000000000000000000000000000000000000000..b3ddd152c06ad641e45bbdc6c3db239d7eef35a2
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/6/quantization.png differ
diff --git a/fn_gen/nlr_t_no_sched/7/distortion.png b/fn_gen/nlr_t_no_sched/7/distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..6aef20626260e7f5fec46c282d683f58df448604
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/7/distortion.png differ
diff --git a/fn_gen/nlr_t_no_sched/7/expressions.txt b/fn_gen/nlr_t_no_sched/7/expressions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ecd6e238827dcdb95f4bcb390c1c300696f34254
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/7/expressions.txt
@@ -0,0 +1,2 @@
+sin(_0*x)/_s
+asin(_s*x)/_0
\ No newline at end of file
diff --git a/fn_gen/nlr_t_no_sched/7/fn.py b/fn_gen/nlr_t_no_sched/7/fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e20158eb726bdaeb3b65697501e8ed4be44cfa6
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/7/fn.py
@@ -0,0 +1,479 @@
+from __future__ import annotations
+
+import torch
+from torch import amin  # Necessary for arcsin
+import copy
+import torch.nn as nn
+import numpy as np
+
+from scipy.optimize import curve_fit
+from typing import Dict, Any, Tuple, List, Callable
+
+
+def quantization(x, **params):
+	return (torch.div(1, replace_num(params['_s'], num=0, to=10000)) * torch.sin((params['_0'] * x)))
+
+
+def dequantization(x, **params):
+	return (torch.div(1, replace_num(params['_0'], num=0, to=10000)) * torch.asin(domain_guard((params['_s'] * x), min=-0.99999, max=0.99999, nan=0)))
+
+
+def init_params(x: torch.Tensor, **kwargs: Dict[str, Any]) -> Dict[str, nn.Parameter]:
+	base_p0 = {
+	'_0': init_space_search(x, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], param='_0', **kwargs),
+	}
+
+	base_p0['_s'] = init_linear_scale(x, qtz_func=quantization, params=base_p0, **kwargs)
+	if 'post_init_hook' in kwargs:
+		kwargs['post_init_hook'](parameters=base_p0)
+	
+	params = init_non_linear_regression_fit(x, p0=base_p0, np_fit_func=fit_func, qtz_func=quantization, deqtz_func=dequantization, params_list=['_0', '_s'], **kwargs)
+	params = {k: nn.Parameter(v, requires_grad=False) for k, v in params.items()}
+	if 'post_method_hook' in kwargs:
+		kwargs['post_method_hook'](parameters=params)
+	
+	params = learn_parameters(x, params,
+		qtz_func=quantization,
+		deqtz_func=dequantization,
+		bits=kwargs['bits'],
+		target_dtype=torch.int8,
+		epochs=500,
+		early_stop=False,
+	)
+	if 'post_train_hook' in kwargs:
+		kwargs['post_train_hook'](parameters=params)
+	
+	return params
+
+
+############### Numpy Qtz ###############
+
+
+def np_quantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_s, num=0, to=10000)) * np.sin((_0 * x)))
+
+
+def np_dequantization(x, _0, _s):
+	return (np.divide(1, np_replace_num(_0, num=0, to=10000)) * np.arcsin(np_domain_guard((_s * x), min=-0.99999, max=0.99999, nan=0)))
+
+
+def fit_func(x, _0, _s):
+    x_ = np_quantization(x, _0, _s)
+    x_ = np_dequantization(x_, _0, _s)
+    return x_
+
+
+
+############### HELPERS ###############
+
+def domain_guard(
+        x: torch.Tensor, 
+        min: float = None, 
+        max: float = None, 
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> torch.Tensor:
+    """Guard a tensor to a valid domain."""
+    x = torch.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = torch.clamp(x, min=min, max=max)
+    return x
+
+
+def replace_num(x: torch.Tensor, num: float, to: float) -> torch.Tensor:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (torch.Tensor): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        torch.Tensor: The tensor with the number replaced.
+    """
+    return torch.where(x == num, to, x)
+
+
+def guarded_torch_power(x: torch.Tensor, exp: float) -> torch.Tensor:
+    """Guard the power operation to a valid domain."""
+    return torch.pow(x, exp) if exp >= 1 else torch.pow(torch.relu(x), exp)
+
+
+def init_ones(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.ones_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_rand(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.randn_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_space_search(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    def _build_initial_param(tensor: torch.Tensor, max_initial: int, n_params: int):
+        """Generates the initial set of parameters. The first iteration generates 10 times more parameters."""
+        for _ in range(n_params * 10):  # The first iteration generates 10 times more parameters
+            yield init_rand(tensor) * max_initial  # Generates n_params in range [-max_initial, max_initial]
+
+    def _search_param(tensors: List[torch.tensor], n_params):
+        """Takes the best parameters and generates new parameters around the mean of the best parameters."""
+        torch_tensors = torch.stack(tensors)
+        min_vals, max_vals = torch.aminmax(torch_tensors, dim=0)
+        abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+        mean = torch.mean(torch_tensors, dim=0)
+        for _ in range(n_params):  # Generates n_params around the mean of the tensors
+            yield torch.randn_like(min_vals) * abs_max_val_per_ch + mean
+
+    def _calc(x, qtz_func, deqtz_func, **params):
+        x_ = x.transpose(0, 1)
+        x_ = qtz_func(x=x_, **params)
+        x_ = deqtz_func(x=x_, **params)
+        x_ = x_.transpose(0, 1)
+        return x_
+
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+    assert "deqtz_func" in kwargs, "deqtz_func must be provided."
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "param" in kwargs, "param must be provided."
+
+    qtz_func = kwargs.get('qtz_func')
+    deqtz_func = kwargs.get('deqtz_func')
+    params_list = kwargs.get('params_list')
+    param = kwargs.get('param')
+
+    n_runs = 50                # Number of runs to try to find the best parameters
+    n_random_params = 50       # Number of random parameters to generate
+    n_best_to_pick = 5         # Number of best parameters to pick after each run
+    max_initial = 10000        # Maximum value to initialize the parameters
+
+    # Initializes the parameters
+    base_params = { p: init_ones(x, **kwargs) for p in params_list if p != param }
+    params = _build_initial_param(x, max_initial, n_random_params)
+
+    # Performs the search
+    for _ in range(n_runs):
+        
+        best_params = []
+        for param_ in params:
+            try:
+                x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: param_})
+                loss_ones = nn.MSELoss()(x, x_)
+
+                if len(best_params) < n_best_to_pick:
+                    best_params.append((param_, loss_ones.item()))
+                    best_params = sorted(best_params, key=lambda x: x[1])
+                elif loss_ones < best_params[-1][1]:
+                    best_params[-1] = (param_, loss_ones.item())
+                    best_params = sorted(best_params, key=lambda x: x[1])
+
+            except Exception:  # The parameters might not be valid for the function's domain
+                continue
+
+        # Generates new parameters around the mean
+        params = _search_param([p for p, _ in best_params], n_random_params)
+
+    # Checks if the best parameter is better than the init_ones
+    p_ones = init_ones(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_ones})
+    loss_ones = nn.MSELoss()(x, x_)
+
+    # Checks if the best parameter is better than the init_rand
+    p_rand = init_rand(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_rand})
+    loss_rand = nn.MSELoss()(x, x_)
+
+    if loss_rand < best_params[0][1] and loss_rand < loss_ones:
+        return p_rand
+    elif loss_ones < best_params[0][1] and loss_ones < loss_rand:
+        return p_ones
+    else:
+        return best_params[0][0]
+
+
+def init_linear_scale(  # Symmetric scale. From the study folder
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+    assert "bits" in kwargs, "bits must be provided."
+    assert "params" in kwargs, "params must be provided."
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+
+    bits = kwargs.get('bits')
+    params = kwargs.get('params')
+    qtz_func = kwargs.get('qtz_func')
+
+    x_ = x.transpose(0, 1)
+    x_ = qtz_func(x=x_, **params, _s=init_ones(x, **kwargs))
+    x_ = x_.transpose(0, 1)
+    
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    min_vals, max_vals = torch.aminmax(x_, dim=1)
+    min_vals = torch.min(min_vals, torch.zeros_like(min_vals))
+    max_vals = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    eps = torch.finfo(torch.float32).eps
+
+    abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+    scale = abs_max_val_per_ch / (float(quant_max - quant_min) / 2)
+    
+    scale = torch.clamp(scale, min=eps).to(dtype=torch.float32, device=min_vals.device)
+
+    # Introduces some noise in scale
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything.
+    # NOTE(diogo): This has been disproven. The noise does not help the learning process but I still
+    # left it here for future reference. Will be removed later.
+    # scale = scale + 0.01 * torch.randn_like(scale)
+
+    return scale
+
+
+def init_non_linear_regression_fit(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "np_fit_func" in kwargs, "np_fit_func must be provided."
+    assert "p0" in kwargs, "p0 must be provided."
+    np_fit_func = kwargs.get('np_fit_func')
+    params_list = kwargs.get('params_list')
+    p0 = kwargs.get('p0')
+
+    def _fit(xdata: np.ndarray, ydata: np.ndarray, func: Callable, p0: List[float]):
+        popt, _ = curve_fit(
+            func, 
+            xdata, 
+            ydata, 
+            maxfev=1000,
+            p0=p0,
+            method='lm'
+        )
+        return popt
+
+    # 1. Needs to convert the torch tensor to numpy tensor
+    xdata = x.cpu().numpy()
+
+    # 2. Sorts the data so that it makes it easier to fit to it
+    sorted_xdata = np.sort(xdata, axis=-1)
+
+    p0 = {k: v.cpu().numpy() for k, v in p0.items()}
+    params_list = sorted(params_list)  # We need to make sure that it matches the numpy fit func arg order
+
+    # 3. Finds the best parameters for each channel
+    try:
+        params = []
+        for i in range(sorted_xdata.shape[0]):
+            xdata_ = sorted_xdata[i]
+            p0_ = [p0[p][i] for p in params_list]
+            ch_params = _fit(xdata_, xdata_, np_fit_func, p0_)
+            params.append(ch_params)
+
+        # 4. Builds the parameters
+        result = {}
+        for i, p in enumerate(params_list):
+            result[p] = torch.tensor([p_[i] for p_ in params], dtype=torch.float32).to(x.device)
+
+        return result
+
+    except ValueError as e:
+        print(f"Could not fit the function with error: {e}")
+        print(f"Using fallback result...")
+        return {
+            k: torch.tensor(v, dtype=torch.float32).to(x.device) for k, v in p0.items()
+        }
+
+
+def init_zeros(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.zeros_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_inner_scale(tensor: torch.Tensor, _min: float = torch.inf, _max: float = torch.inf) -> torch.Tensor:
+    # Calculate the original minimum and maximum values
+    min_vals, max_vals = torch.aminmax(tensor, dim=-1)
+    x_min = torch.min(min_vals, torch.zeros_like(min_vals))
+    x_max = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    if _max is torch.inf:  # We do not need to scale the tensor. Just need to move it
+        return torch.ones_like(x_min)
+    
+    # Calculate the scale factor
+    scale = (_max - _min) / (x_max - x_min)
+    return scale
+
+
+
+############## Quant ###############
+
+@torch.enable_grad()
+def learn_parameters(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    qtz_func: nn.Module,
+    deqtz_func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype,
+    epochs: int = 1000,
+    early_stop: bool = True,
+    do_report: bool = False
+) -> Tuple[Dict[str, nn.Parameter], torch.Tensor]:
+    loss_fn = nn.MSELoss()
+
+    # Determines the initial learning rate by computing the initial loss and multiplying it by
+    # the order of magnitude of the loss divided by 2
+    quant = quantize(x, params, qtz_func, bits, target_dtype)
+    dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+    loss = loss_fn(x, dequant)
+
+    base_lr = 0.1
+    exponent = int(np.floor(np.log10(loss.item())))
+    lr = base_lr * (10 ** (exponent // 2))
+    
+    # Requires gradients in the parameters
+    for p in params.values():
+        p.requires_grad = True
+        p.grad = None
+
+    param_keys = list(params.keys())
+    param_values = list(params.values())
+
+    # Defines optimizer and loss function
+    optimizer = torch.optim.Adam(param_values, lr=lr)
+
+    # Contains the best loss and the best parameters 
+    best_loss = float("inf")
+    best_params = None
+
+    # Used to stop the search early
+    min_delta = 1e-7
+    acc_loss = []
+    percent_epochs_before_stop = 0.1
+
+    for i in range(epochs):
+        optimizer.zero_grad()
+
+        quant = quantize(x, params, qtz_func, bits, target_dtype)
+        dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+        loss = loss_fn(x, dequant)
+
+        if loss.isnan() or loss.isinf():
+            raise Exception("Loss is NaN or Inf. Stopping the search.")
+
+        loss.backward()
+        optimizer.step()
+
+        acc_loss.append(loss.item())
+
+        # Reports loss every 10 steps
+        if i % 10 == 0 and do_report:
+            print(f"Epoch {i}: Loss {loss.item()}")
+
+        # Optimizes the parameter search by storing the best loss and the parameters
+        if loss.item() < best_loss:
+            best_loss = loss.item()
+            best_params = copy.deepcopy({
+                k: v for k, v in params.items() if k in param_keys
+            })
+
+        # We also stop the search if the loss has not considerably during the last 10% epochs
+        if early_stop:
+            epochs_before_stop = int(epochs * percent_epochs_before_stop)
+            if i > epochs_before_stop and abs(acc_loss[i - epochs_before_stop] - acc_loss[i]) < min_delta:
+                break
+
+    # No longer requires gradients in the parameters
+    for p in best_params.values():
+        p.requires_grad = False
+        p.grad = None
+    
+    if do_report:
+        print(f"Best loss: {best_loss}")
+        return best_params, acc_loss
+    else:
+        return best_params
+
+
+def quantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype = torch.int8
+) -> torch.Tensor:
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    x = x.transpose(0, 1)  # Aligns shapes
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    x = torch.clamp(round_func_BPDA(x), quant_min, quant_max).to(target_dtype)
+    return x
+
+
+def dequantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    out_dtype: torch.dtype
+) -> torch.Tensor:
+    x = x.to(dtype=out_dtype)
+    x = x.transpose(0, 1)
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    return x
+
+
+def round_func_BPDA(input):
+    # This is equivalent to replacing round function (non-differentiable) with
+    # an identity function (differentiable) only when backward.
+    forward_value = torch.round(input)
+    out = input.clone()
+    out.data = forward_value.data
+    return out
+
+
+def get_min_max_from_bits_signed(bit_width: int) -> Tuple[int, int]:
+    return -2 ** (bit_width - 1), 2 ** (bit_width - 1) - 1
+
+
+
+############## Numpy ###############
+
+def np_domain_guard(
+        x: np.ndarray,
+        min: float = None,
+        max: float = None,
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> np.ndarray:
+    """Guard a tensor to a valid domain."""
+    x = np.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = np.clip(x, min, max)
+    return x
+
+
+def np_replace_num(x: np.ndarray, num: float, to: float) -> np.ndarray:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (np.ndarray): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        np.ndarray: The tensor with the number replaced.
+    """
+    return np.where(x == num, to, x)
+
+
+def np_guarded_power(x: np.ndarray, exp: float) -> np.ndarray:
+    """Guard the power operation to a valid domain."""
+    return np.power(x, exp) if exp >= 1 else np.power(np.maximum(x, 0), exp)
+
diff --git a/fn_gen/nlr_t_no_sched/7/loss.png b/fn_gen/nlr_t_no_sched/7/loss.png
new file mode 100644
index 0000000000000000000000000000000000000000..348dd363005c8da4d183e14d3d0df26d08c6e4fd
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/7/loss.png differ
diff --git a/fn_gen/nlr_t_no_sched/7/quantization.png b/fn_gen/nlr_t_no_sched/7/quantization.png
new file mode 100644
index 0000000000000000000000000000000000000000..ba27cdd91e47a7aa0b97a51c5f954f648d816764
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/7/quantization.png differ
diff --git a/fn_gen/nlr_t_no_sched/8/distortion.png b/fn_gen/nlr_t_no_sched/8/distortion.png
new file mode 100644
index 0000000000000000000000000000000000000000..993a0551a32295f8fa2bdf95d175c7931ce1efb7
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/8/distortion.png differ
diff --git a/fn_gen/nlr_t_no_sched/8/expressions.txt b/fn_gen/nlr_t_no_sched/8/expressions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6d6553d091cd1d343d7aa9b52b85ef6ec88ea854
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/8/expressions.txt
@@ -0,0 +1,2 @@
+x/_s
+_s*x
\ No newline at end of file
diff --git a/fn_gen/nlr_t_no_sched/8/fn.py b/fn_gen/nlr_t_no_sched/8/fn.py
new file mode 100644
index 0000000000000000000000000000000000000000..246b875350c92ae056e2f10993e025d130ad1908
--- /dev/null
+++ b/fn_gen/nlr_t_no_sched/8/fn.py
@@ -0,0 +1,478 @@
+from __future__ import annotations
+
+import torch
+from torch import amin  # Necessary for arcsin
+import copy
+import torch.nn as nn
+import numpy as np
+
+from scipy.optimize import curve_fit
+from typing import Dict, Any, Tuple, List, Callable
+
+
+def quantization(x, **params):
+	return (x * torch.div(1, replace_num(params['_s'], num=0, to=10000)))
+
+
+def dequantization(x, **params):
+	return (params['_s'] * x)
+
+
+def init_params(x: torch.Tensor, **kwargs: Dict[str, Any]) -> Dict[str, nn.Parameter]:
+	base_p0 = {
+	}
+
+	base_p0['_s'] = init_linear_scale(x, qtz_func=quantization, params=base_p0, **kwargs)
+	if 'post_init_hook' in kwargs:
+		kwargs['post_init_hook'](parameters=base_p0)
+	
+	params = init_non_linear_regression_fit(x, p0=base_p0, np_fit_func=fit_func, qtz_func=quantization, deqtz_func=dequantization, params_list=['_s'], **kwargs)
+	params = {k: nn.Parameter(v, requires_grad=False) for k, v in params.items()}
+	if 'post_method_hook' in kwargs:
+		kwargs['post_method_hook'](parameters=params)
+	
+	params = learn_parameters(x, params,
+		qtz_func=quantization,
+		deqtz_func=dequantization,
+		bits=kwargs['bits'],
+		target_dtype=torch.int8,
+		epochs=500,
+		early_stop=False,
+	)
+	if 'post_train_hook' in kwargs:
+		kwargs['post_train_hook'](parameters=params)
+	
+	return params
+
+
+############### Numpy Qtz ###############
+
+
+def np_quantization(x, _s):
+	return (x * np.divide(1, np_replace_num(_s, num=0, to=10000)))
+
+
+def np_dequantization(x, _s):
+	return (_s * x)
+
+
+def fit_func(x, _s):
+    x_ = np_quantization(x, _s)
+    x_ = np_dequantization(x_, _s)
+    return x_
+
+
+
+############### HELPERS ###############
+
+def domain_guard(
+        x: torch.Tensor, 
+        min: float = None, 
+        max: float = None, 
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> torch.Tensor:
+    """Guard a tensor to a valid domain."""
+    x = torch.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = torch.clamp(x, min=min, max=max)
+    return x
+
+
+def replace_num(x: torch.Tensor, num: float, to: float) -> torch.Tensor:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (torch.Tensor): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        torch.Tensor: The tensor with the number replaced.
+    """
+    return torch.where(x == num, to, x)
+
+
+def guarded_torch_power(x: torch.Tensor, exp: float) -> torch.Tensor:
+    """Guard the power operation to a valid domain."""
+    return torch.pow(x, exp) if exp >= 1 else torch.pow(torch.relu(x), exp)
+
+
+def init_ones(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.ones_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_rand(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.randn_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_space_search(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    def _build_initial_param(tensor: torch.Tensor, max_initial: int, n_params: int):
+        """Generates the initial set of parameters. The first iteration generates 10 times more parameters."""
+        for _ in range(n_params * 10):  # The first iteration generates 10 times more parameters
+            yield init_rand(tensor) * max_initial  # Generates n_params in range [-max_initial, max_initial]
+
+    def _search_param(tensors: List[torch.tensor], n_params):
+        """Takes the best parameters and generates new parameters around the mean of the best parameters."""
+        torch_tensors = torch.stack(tensors)
+        min_vals, max_vals = torch.aminmax(torch_tensors, dim=0)
+        abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+        mean = torch.mean(torch_tensors, dim=0)
+        for _ in range(n_params):  # Generates n_params around the mean of the tensors
+            yield torch.randn_like(min_vals) * abs_max_val_per_ch + mean
+
+    def _calc(x, qtz_func, deqtz_func, **params):
+        x_ = x.transpose(0, 1)
+        x_ = qtz_func(x=x_, **params)
+        x_ = deqtz_func(x=x_, **params)
+        x_ = x_.transpose(0, 1)
+        return x_
+
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+    assert "deqtz_func" in kwargs, "deqtz_func must be provided."
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "param" in kwargs, "param must be provided."
+
+    qtz_func = kwargs.get('qtz_func')
+    deqtz_func = kwargs.get('deqtz_func')
+    params_list = kwargs.get('params_list')
+    param = kwargs.get('param')
+
+    n_runs = 50                # Number of runs to try to find the best parameters
+    n_random_params = 50       # Number of random parameters to generate
+    n_best_to_pick = 5         # Number of best parameters to pick after each run
+    max_initial = 10000        # Maximum value to initialize the parameters
+
+    # Initializes the parameters
+    base_params = { p: init_ones(x, **kwargs) for p in params_list if p != param }
+    params = _build_initial_param(x, max_initial, n_random_params)
+
+    # Performs the search
+    for _ in range(n_runs):
+        
+        best_params = []
+        for param_ in params:
+            try:
+                x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: param_})
+                loss_ones = nn.MSELoss()(x, x_)
+
+                if len(best_params) < n_best_to_pick:
+                    best_params.append((param_, loss_ones.item()))
+                    best_params = sorted(best_params, key=lambda x: x[1])
+                elif loss_ones < best_params[-1][1]:
+                    best_params[-1] = (param_, loss_ones.item())
+                    best_params = sorted(best_params, key=lambda x: x[1])
+
+            except Exception:  # The parameters might not be valid for the function's domain
+                continue
+
+        # Generates new parameters around the mean
+        params = _search_param([p for p, _ in best_params], n_random_params)
+
+    # Checks if the best parameter is better than the init_ones
+    p_ones = init_ones(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_ones})
+    loss_ones = nn.MSELoss()(x, x_)
+
+    # Checks if the best parameter is better than the init_rand
+    p_rand = init_rand(x, **kwargs)
+    x_ = _calc(x, qtz_func, deqtz_func, **base_params, **{param: p_rand})
+    loss_rand = nn.MSELoss()(x, x_)
+
+    if loss_rand < best_params[0][1] and loss_rand < loss_ones:
+        return p_rand
+    elif loss_ones < best_params[0][1] and loss_ones < loss_rand:
+        return p_ones
+    else:
+        return best_params[0][0]
+
+
+def init_linear_scale(  # Symmetric scale. From the study folder
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+    assert "bits" in kwargs, "bits must be provided."
+    assert "params" in kwargs, "params must be provided."
+    assert "qtz_func" in kwargs, "qtz_func must be provided."
+
+    bits = kwargs.get('bits')
+    params = kwargs.get('params')
+    qtz_func = kwargs.get('qtz_func')
+
+    x_ = x.transpose(0, 1)
+    x_ = qtz_func(x=x_, **params, _s=init_ones(x, **kwargs))
+    x_ = x_.transpose(0, 1)
+    
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    min_vals, max_vals = torch.aminmax(x_, dim=1)
+    min_vals = torch.min(min_vals, torch.zeros_like(min_vals))
+    max_vals = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    eps = torch.finfo(torch.float32).eps
+
+    abs_max_val_per_ch = torch.max(-min_vals, max_vals)
+    scale = abs_max_val_per_ch / (float(quant_max - quant_min) / 2)
+    
+    scale = torch.clamp(scale, min=eps).to(dtype=torch.float32, device=min_vals.device)
+
+    # Introduces some noise in scale
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything
+    # If I don't introduce noise, the accuracy is going to be 0.0 and not learn anything.
+    # NOTE(diogo): This has been disproven. The noise does not help the learning process but I still
+    # left it here for future reference. Will be removed later.
+    # scale = scale + 0.01 * torch.randn_like(scale)
+
+    return scale
+
+
+def init_non_linear_regression_fit(
+        x: torch.Tensor,
+        **kwargs: Dict[str, Any],
+    ) -> torch.Tensor:
+
+    assert "params_list" in kwargs, "params list must be provided."
+    assert "np_fit_func" in kwargs, "np_fit_func must be provided."
+    assert "p0" in kwargs, "p0 must be provided."
+    np_fit_func = kwargs.get('np_fit_func')
+    params_list = kwargs.get('params_list')
+    p0 = kwargs.get('p0')
+
+    def _fit(xdata: np.ndarray, ydata: np.ndarray, func: Callable, p0: List[float]):
+        popt, _ = curve_fit(
+            func, 
+            xdata, 
+            ydata, 
+            maxfev=1000,
+            p0=p0,
+            method='lm'
+        )
+        return popt
+
+    # 1. Needs to convert the torch tensor to numpy tensor
+    xdata = x.cpu().numpy()
+
+    # 2. Sorts the data so that it makes it easier to fit to it
+    sorted_xdata = np.sort(xdata, axis=-1)
+
+    p0 = {k: v.cpu().numpy() for k, v in p0.items()}
+    params_list = sorted(params_list)  # We need to make sure that it matches the numpy fit func arg order
+
+    # 3. Finds the best parameters for each channel
+    try:
+        params = []
+        for i in range(sorted_xdata.shape[0]):
+            xdata_ = sorted_xdata[i]
+            p0_ = [p0[p][i] for p in params_list]
+            ch_params = _fit(xdata_, xdata_, np_fit_func, p0_)
+            params.append(ch_params)
+
+        # 4. Builds the parameters
+        result = {}
+        for i, p in enumerate(params_list):
+            result[p] = torch.tensor([p_[i] for p_ in params], dtype=torch.float32).to(x.device)
+
+        return result
+
+    except ValueError as e:
+        print(f"Could not fit the function with error: {e}")
+        print(f"Using fallback result...")
+        return {
+            k: torch.tensor(v, dtype=torch.float32).to(x.device) for k, v in p0.items()
+        }
+
+
+def init_zeros(x: torch.Tensor, **kwargs: Dict[str, Any]) -> torch.Tensor:
+    val = torch.amin(x, dim=1)
+    return torch.zeros_like(val, dtype=torch.float32, device=x.device)
+
+
+def init_inner_scale(tensor: torch.Tensor, _min: float = torch.inf, _max: float = torch.inf) -> torch.Tensor:
+    # Calculate the original minimum and maximum values
+    min_vals, max_vals = torch.aminmax(tensor, dim=-1)
+    x_min = torch.min(min_vals, torch.zeros_like(min_vals))
+    x_max = torch.max(max_vals, torch.zeros_like(max_vals))
+
+    if _max is torch.inf:  # We do not need to scale the tensor. Just need to move it
+        return torch.ones_like(x_min)
+    
+    # Calculate the scale factor
+    scale = (_max - _min) / (x_max - x_min)
+    return scale
+
+
+
+############## Quant ###############
+
+@torch.enable_grad()
+def learn_parameters(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    qtz_func: nn.Module,
+    deqtz_func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype,
+    epochs: int = 1000,
+    early_stop: bool = True,
+    do_report: bool = False
+) -> Tuple[Dict[str, nn.Parameter], torch.Tensor]:
+    loss_fn = nn.MSELoss()
+
+    # Determines the initial learning rate by computing the initial loss and multiplying it by
+    # the order of magnitude of the loss divided by 2
+    quant = quantize(x, params, qtz_func, bits, target_dtype)
+    dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+    loss = loss_fn(x, dequant)
+
+    base_lr = 0.1
+    exponent = int(np.floor(np.log10(loss.item())))
+    lr = base_lr * (10 ** (exponent // 2))
+    
+    # Requires gradients in the parameters
+    for p in params.values():
+        p.requires_grad = True
+        p.grad = None
+
+    param_keys = list(params.keys())
+    param_values = list(params.values())
+
+    # Defines optimizer and loss function
+    optimizer = torch.optim.Adam(param_values, lr=lr)
+
+    # Contains the best loss and the best parameters 
+    best_loss = float("inf")
+    best_params = None
+
+    # Used to stop the search early
+    min_delta = 1e-7
+    acc_loss = []
+    percent_epochs_before_stop = 0.1
+
+    for i in range(epochs):
+        optimizer.zero_grad()
+
+        quant = quantize(x, params, qtz_func, bits, target_dtype)
+        dequant = dequantize(quant, params, deqtz_func, bits, x.dtype)
+        loss = loss_fn(x, dequant)
+
+        if loss.isnan() or loss.isinf():
+            raise Exception("Loss is NaN or Inf. Stopping the search.")
+
+        loss.backward()
+        optimizer.step()
+
+        acc_loss.append(loss.item())
+
+        # Reports loss every 10 steps
+        if i % 10 == 0 and do_report:
+            print(f"Epoch {i}: Loss {loss.item()}")
+
+        # Optimizes the parameter search by storing the best loss and the parameters
+        if loss.item() < best_loss:
+            best_loss = loss.item()
+            best_params = copy.deepcopy({
+                k: v for k, v in params.items() if k in param_keys
+            })
+
+        # We also stop the search if the loss has not considerably during the last 10% epochs
+        if early_stop:
+            epochs_before_stop = int(epochs * percent_epochs_before_stop)
+            if i > epochs_before_stop and abs(acc_loss[i - epochs_before_stop] - acc_loss[i]) < min_delta:
+                break
+
+    # No longer requires gradients in the parameters
+    for p in best_params.values():
+        p.requires_grad = False
+        p.grad = None
+    
+    if do_report:
+        print(f"Best loss: {best_loss}")
+        return best_params, acc_loss
+    else:
+        return best_params
+
+
+def quantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    target_dtype: torch.dtype = torch.int8
+) -> torch.Tensor:
+    quant_min, quant_max = get_min_max_from_bits_signed(bits)
+    x = x.transpose(0, 1)  # Aligns shapes
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    x = torch.clamp(round_func_BPDA(x), quant_min, quant_max).to(target_dtype)
+    return x
+
+
+def dequantize(
+    x: torch.Tensor,
+    params: Dict[str, nn.Parameter],
+    func: nn.Module,
+    bits: int,
+    out_dtype: torch.dtype
+) -> torch.Tensor:
+    x = x.to(dtype=out_dtype)
+    x = x.transpose(0, 1)
+    x = func(x=x, **params)
+    x = x.transpose(0, 1)
+    return x
+
+
+def round_func_BPDA(input):
+    # This is equivalent to replacing round function (non-differentiable) with
+    # an identity function (differentiable) only when backward.
+    forward_value = torch.round(input)
+    out = input.clone()
+    out.data = forward_value.data
+    return out
+
+
+def get_min_max_from_bits_signed(bit_width: int) -> Tuple[int, int]:
+    return -2 ** (bit_width - 1), 2 ** (bit_width - 1) - 1
+
+
+
+############## Numpy ###############
+
+def np_domain_guard(
+        x: np.ndarray,
+        min: float = None,
+        max: float = None,
+        posinf: float = None,
+        neginf: float = None,
+        nan: float = None
+    ) -> np.ndarray:
+    """Guard a tensor to a valid domain."""
+    x = np.nan_to_num(x, posinf=posinf, neginf=neginf, nan=nan)
+    if min is not None or max is not None:
+        x = np.clip(x, min, max)
+    return x
+
+
+def np_replace_num(x: np.ndarray, num: float, to: float) -> np.ndarray:
+    """Replace a number in a tensor with another number.
+    
+    Args:
+        x (np.ndarray): The input tensor.
+        num (float): The number to replace.
+        to (float): The number to replace with.
+
+    Returns:
+        np.ndarray: The tensor with the number replaced.
+    """
+    return np.where(x == num, to, x)
+
+
+def np_guarded_power(x: np.ndarray, exp: float) -> np.ndarray:
+    """Guard the power operation to a valid domain."""
+    return np.power(x, exp) if exp >= 1 else np.power(np.maximum(x, 0), exp)
+
diff --git a/fn_gen/nlr_t_no_sched/8/loss.png b/fn_gen/nlr_t_no_sched/8/loss.png
new file mode 100644
index 0000000000000000000000000000000000000000..5aa716c87e530384fe904e47fbeb86ef1c5f22e8
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/8/loss.png differ
diff --git a/fn_gen/nlr_t_no_sched/8/quantization.png b/fn_gen/nlr_t_no_sched/8/quantization.png
new file mode 100644
index 0000000000000000000000000000000000000000..40f341fdd30b311f08f84cc870857523d0192b20
Binary files /dev/null and b/fn_gen/nlr_t_no_sched/8/quantization.png differ