You can now access the parameters and variables as a dictionary using:

param = cp.Parameter(name='paramname')
problem.param_dict

and

var = cp.Variable(name='varname')
problem.var_dict

where the parameter/variable names are the keys of the dictionary

Hi Philippe! Could you try timing the optimization with the CPP and SciPy different backends?
https://www.cvxpy.org/tutorial/advanced/index.html#canonicalization-backends

Could you format the results with the info:
Number of parameters | compilation time with CPP backend | compilation time with SciPy backend | compilation time with CPP backend and ignore_dpp=True

Named constants would be reasonable but if the SciPy backend is fast enough it might make sense to add logic to trigger it automatically when there are enough parameters. It was designed to be much faster with parameters than the CPP backend. @phschiele what do you think?

Looking at the docs we find that this is expected:

As another example, the quotient expr / p is not DPP-compliant when p is a parameter, but this can be rewritten as expr * p_tilde, where p_tilde is a parameter that represents 1/p.

But in your case we need both p and 1 / p? Keeping those two synchronized is challenging. We can use a class we'll call ReciprocalParameter to make it easier.

import cvxpy as cp
from typing import Optional

class ReciprocalParameter:
    """Used for times when you want a cvxpy Parameter and its ratio"""

    def __init__(self, *args, **kwargs) -> None:
        self._p = cp.Parameter(*args, **kwargs)
        # Reciprocal of the above
        self._rp = cp.Parameter(*args, **kwargs)

    @property
    def value(self) -> Optional[float]:
        """Return the value of the Parameter"""
        return self._p.value

    @value.setter
    def value(self, val: Optional[float]) -> None:
        """
        Simultaneously set the value of the Parameter (given by `p`)
        and its reciprocal (given by `rp`)
        """
        self._p.value = val
        self._rp.value = 1 / val if val is not None else None

    @property
    def p(self) -> cp.Parameter:
        """Returns the parameter"""
        return self._p

    @property
    def rp(self) -> cp.Parameter:
        """Returns the reciprocal of the parameter"""
        return self._rp

def cp_log_ratio_norm(a, b: ReciprocalParameter):
  # Both `a * cp.inv_pos(b)` and `a / b` make this problem non-DPP
  return cp.maximum(a * b.rp, b.p * cp.inv_pos(a))

var = cp.Variable(pos=True)
param = ReciprocalParameter(pos=True)
param.value = 5
objective = cp.Minimize(cp_log_ratio_norm(var, param))
problem = cp.Problem(objective, [])
objective_value = problem.solve()

print(f"Objective value = {objective_value}")
print(f"Status = {problem.status}")

Note that we treat ReciprocalParameter just like a normal cvxpy.Parameter until the point of use when we are forced to decide whether we want the parameter's value (ReciprocalParameter.p) or its reciprocal (ReciprocalParameter.rp).