diff --git a/.gitattributes b/.gitattributes
index 26868d10b97f1c6961a627754ef4e39eeac528bf..aae142219378ae82f9bf1cbe423684ba540bddf6 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1635,3 +1635,6 @@ parrot/lib/python3.10/site-packages/scipy/special/_ellip_harm_2.cpython-310-x86_
parrot/lib/python3.10/site-packages/pandas/_libs/lib.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
wemm/lib/python3.10/site-packages/nvidia/cuda_nvrtc/lib/libnvrtc.so.11.2 filter=lfs diff=lfs merge=lfs -text
vllm/lib/python3.10/site-packages/fastrlock/rlock.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+parrot/lib/python3.10/site-packages/scipy/interpolate/interpnd.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+vllm/lib/python3.10/site-packages/transformers/generation/__pycache__/tf_utils.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+vllm/lib/python3.10/site-packages/transformers/generation/__pycache__/logits_process.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
diff --git a/parrot/lib/python3.10/site-packages/scipy/interpolate/interpnd.cpython-310-x86_64-linux-gnu.so b/parrot/lib/python3.10/site-packages/scipy/interpolate/interpnd.cpython-310-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..e1c425496245b57d4b9d2cbfa532224b3f42fc36
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/interpolate/interpnd.cpython-310-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:858919e18e295550cd7be75e89651b5d12ad97a9e2d3c540da006b42c42ac19c
+size 458776
diff --git a/parrot/lib/python3.10/site-packages/scipy/linalg/tests/data/carex_20_data.npz b/parrot/lib/python3.10/site-packages/scipy/linalg/tests/data/carex_20_data.npz
new file mode 100644
index 0000000000000000000000000000000000000000..87266deb46238307347362b63a4878f2565baf56
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/linalg/tests/data/carex_20_data.npz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14e222d34a7118c7284a1675c6feceee77b84df951a5c6ba2a5ee9ff3054fa1d
+size 31231
diff --git a/parrot/lib/python3.10/site-packages/scipy/linalg/tests/data/gendare_20170120_data.npz b/parrot/lib/python3.10/site-packages/scipy/linalg/tests/data/gendare_20170120_data.npz
new file mode 100644
index 0000000000000000000000000000000000000000..ff967f2ca0d0868aacf7d7e67402599e64bab817
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/linalg/tests/data/gendare_20170120_data.npz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a3dfab451d9d5c20243e0ed85cd8b6c9657669fb9a0f83b5be165585783d55b5
+size 2164
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_linprog_highs.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_linprog_highs.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb07443bb255471e6e0ac487bd6749253bf5d133
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_linprog_highs.py
@@ -0,0 +1,440 @@
+"""HiGHS Linear Optimization Methods
+
+Interface to HiGHS linear optimization software.
+https://highs.dev/
+
+.. versionadded:: 1.5.0
+
+References
+----------
+.. [1] Q. Huangfu and J.A.J. Hall. "Parallelizing the dual revised simplex
+ method." Mathematical Programming Computation, 10 (1), 119-142,
+ 2018. DOI: 10.1007/s12532-017-0130-5
+
+"""
+
+import inspect
+import numpy as np
+from ._optimize import OptimizeWarning, OptimizeResult
+from warnings import warn
+from ._highs._highs_wrapper import _highs_wrapper
+from ._highs._highs_constants import (
+ CONST_INF,
+ MESSAGE_LEVEL_NONE,
+ HIGHS_OBJECTIVE_SENSE_MINIMIZE,
+
+ MODEL_STATUS_NOTSET,
+ MODEL_STATUS_LOAD_ERROR,
+ MODEL_STATUS_MODEL_ERROR,
+ MODEL_STATUS_PRESOLVE_ERROR,
+ MODEL_STATUS_SOLVE_ERROR,
+ MODEL_STATUS_POSTSOLVE_ERROR,
+ MODEL_STATUS_MODEL_EMPTY,
+ MODEL_STATUS_OPTIMAL,
+ MODEL_STATUS_INFEASIBLE,
+ MODEL_STATUS_UNBOUNDED_OR_INFEASIBLE,
+ MODEL_STATUS_UNBOUNDED,
+ MODEL_STATUS_REACHED_DUAL_OBJECTIVE_VALUE_UPPER_BOUND
+ as MODEL_STATUS_RDOVUB,
+ MODEL_STATUS_REACHED_OBJECTIVE_TARGET,
+ MODEL_STATUS_REACHED_TIME_LIMIT,
+ MODEL_STATUS_REACHED_ITERATION_LIMIT,
+
+ HIGHS_SIMPLEX_STRATEGY_DUAL,
+
+ HIGHS_SIMPLEX_CRASH_STRATEGY_OFF,
+
+ HIGHS_SIMPLEX_EDGE_WEIGHT_STRATEGY_CHOOSE,
+ HIGHS_SIMPLEX_EDGE_WEIGHT_STRATEGY_DANTZIG,
+ HIGHS_SIMPLEX_EDGE_WEIGHT_STRATEGY_DEVEX,
+ HIGHS_SIMPLEX_EDGE_WEIGHT_STRATEGY_STEEPEST_EDGE,
+)
+from scipy.sparse import csc_matrix, vstack, issparse
+
+
+def _highs_to_scipy_status_message(highs_status, highs_message):
+ """Converts HiGHS status number/message to SciPy status number/message"""
+
+ scipy_statuses_messages = {
+ None: (4, "HiGHS did not provide a status code. "),
+ MODEL_STATUS_NOTSET: (4, ""),
+ MODEL_STATUS_LOAD_ERROR: (4, ""),
+ MODEL_STATUS_MODEL_ERROR: (2, ""),
+ MODEL_STATUS_PRESOLVE_ERROR: (4, ""),
+ MODEL_STATUS_SOLVE_ERROR: (4, ""),
+ MODEL_STATUS_POSTSOLVE_ERROR: (4, ""),
+ MODEL_STATUS_MODEL_EMPTY: (4, ""),
+ MODEL_STATUS_RDOVUB: (4, ""),
+ MODEL_STATUS_REACHED_OBJECTIVE_TARGET: (4, ""),
+ MODEL_STATUS_OPTIMAL: (0, "Optimization terminated successfully. "),
+ MODEL_STATUS_REACHED_TIME_LIMIT: (1, "Time limit reached. "),
+ MODEL_STATUS_REACHED_ITERATION_LIMIT: (1, "Iteration limit reached. "),
+ MODEL_STATUS_INFEASIBLE: (2, "The problem is infeasible. "),
+ MODEL_STATUS_UNBOUNDED: (3, "The problem is unbounded. "),
+ MODEL_STATUS_UNBOUNDED_OR_INFEASIBLE: (4, "The problem is unbounded "
+ "or infeasible. ")}
+ unrecognized = (4, "The HiGHS status code was not recognized. ")
+ scipy_status, scipy_message = (
+ scipy_statuses_messages.get(highs_status, unrecognized))
+ scipy_message = (f"{scipy_message}"
+ f"(HiGHS Status {highs_status}: {highs_message})")
+ return scipy_status, scipy_message
+
+
+def _replace_inf(x):
+ # Replace `np.inf` with CONST_INF
+ infs = np.isinf(x)
+ with np.errstate(invalid="ignore"):
+ x[infs] = np.sign(x[infs])*CONST_INF
+ return x
+
+
+def _convert_to_highs_enum(option, option_str, choices):
+ # If option is in the choices we can look it up, if not use
+ # the default value taken from function signature and warn:
+ try:
+ return choices[option.lower()]
+ except AttributeError:
+ return choices[option]
+ except KeyError:
+ sig = inspect.signature(_linprog_highs)
+ default_str = sig.parameters[option_str].default
+ warn(f"Option {option_str} is {option}, but only values in "
+ f"{set(choices.keys())} are allowed. Using default: "
+ f"{default_str}.",
+ OptimizeWarning, stacklevel=3)
+ return choices[default_str]
+
+
+def _linprog_highs(lp, solver, time_limit=None, presolve=True,
+ disp=False, maxiter=None,
+ dual_feasibility_tolerance=None,
+ primal_feasibility_tolerance=None,
+ ipm_optimality_tolerance=None,
+ simplex_dual_edge_weight_strategy=None,
+ mip_rel_gap=None,
+ mip_max_nodes=None,
+ **unknown_options):
+ r"""
+ Solve the following linear programming problem using one of the HiGHS
+ solvers:
+
+ User-facing documentation is in _linprog_doc.py.
+
+ Parameters
+ ----------
+ lp : _LPProblem
+ A ``scipy.optimize._linprog_util._LPProblem`` ``namedtuple``.
+ solver : "ipm" or "simplex" or None
+ Which HiGHS solver to use. If ``None``, "simplex" will be used.
+
+ Options
+ -------
+ maxiter : int
+ The maximum number of iterations to perform in either phase. For
+ ``solver='ipm'``, this does not include the number of crossover
+ iterations. Default is the largest possible value for an ``int``
+ on the platform.
+ disp : bool
+ Set to ``True`` if indicators of optimization status are to be printed
+ to the console each iteration; default ``False``.
+ time_limit : float
+ The maximum time in seconds allotted to solve the problem; default is
+ the largest possible value for a ``double`` on the platform.
+ presolve : bool
+ Presolve attempts to identify trivial infeasibilities,
+ identify trivial unboundedness, and simplify the problem before
+ sending it to the main solver. It is generally recommended
+ to keep the default setting ``True``; set to ``False`` if presolve is
+ to be disabled.
+ dual_feasibility_tolerance : double
+ Dual feasibility tolerance. Default is 1e-07.
+ The minimum of this and ``primal_feasibility_tolerance``
+ is used for the feasibility tolerance when ``solver='ipm'``.
+ primal_feasibility_tolerance : double
+ Primal feasibility tolerance. Default is 1e-07.
+ The minimum of this and ``dual_feasibility_tolerance``
+ is used for the feasibility tolerance when ``solver='ipm'``.
+ ipm_optimality_tolerance : double
+ Optimality tolerance for ``solver='ipm'``. Default is 1e-08.
+ Minimum possible value is 1e-12 and must be smaller than the largest
+ possible value for a ``double`` on the platform.
+ simplex_dual_edge_weight_strategy : str (default: None)
+ Strategy for simplex dual edge weights. The default, ``None``,
+ automatically selects one of the following.
+
+ ``'dantzig'`` uses Dantzig's original strategy of choosing the most
+ negative reduced cost.
+
+ ``'devex'`` uses the strategy described in [15]_.
+
+ ``steepest`` uses the exact steepest edge strategy as described in
+ [16]_.
+
+ ``'steepest-devex'`` begins with the exact steepest edge strategy
+ until the computation is too costly or inexact and then switches to
+ the devex method.
+
+ Currently, using ``None`` always selects ``'steepest-devex'``, but this
+ may change as new options become available.
+
+ mip_max_nodes : int
+ The maximum number of nodes allotted to solve the problem; default is
+ the largest possible value for a ``HighsInt`` on the platform.
+ Ignored if not using the MIP solver.
+ unknown_options : dict
+ Optional arguments not used by this particular solver. If
+ ``unknown_options`` is non-empty, a warning is issued listing all
+ unused options.
+
+ Returns
+ -------
+ sol : dict
+ A dictionary consisting of the fields:
+
+ x : 1D array
+ The values of the decision variables that minimizes the
+ objective function while satisfying the constraints.
+ fun : float
+ The optimal value of the objective function ``c @ x``.
+ slack : 1D array
+ The (nominally positive) values of the slack,
+ ``b_ub - A_ub @ x``.
+ con : 1D array
+ The (nominally zero) residuals of the equality constraints,
+ ``b_eq - A_eq @ x``.
+ success : bool
+ ``True`` when the algorithm succeeds in finding an optimal
+ solution.
+ status : int
+ An integer representing the exit status of the algorithm.
+
+ ``0`` : Optimization terminated successfully.
+
+ ``1`` : Iteration or time limit reached.
+
+ ``2`` : Problem appears to be infeasible.
+
+ ``3`` : Problem appears to be unbounded.
+
+ ``4`` : The HiGHS solver ran into a problem.
+
+ message : str
+ A string descriptor of the exit status of the algorithm.
+ nit : int
+ The total number of iterations performed.
+ For ``solver='simplex'``, this includes iterations in all
+ phases. For ``solver='ipm'``, this does not include
+ crossover iterations.
+ crossover_nit : int
+ The number of primal/dual pushes performed during the
+ crossover routine for ``solver='ipm'``. This is ``0``
+ for ``solver='simplex'``.
+ ineqlin : OptimizeResult
+ Solution and sensitivity information corresponding to the
+ inequality constraints, `b_ub`. A dictionary consisting of the
+ fields:
+
+ residual : np.ndnarray
+ The (nominally positive) values of the slack variables,
+ ``b_ub - A_ub @ x``. This quantity is also commonly
+ referred to as "slack".
+
+ marginals : np.ndarray
+ The sensitivity (partial derivative) of the objective
+ function with respect to the right-hand side of the
+ inequality constraints, `b_ub`.
+
+ eqlin : OptimizeResult
+ Solution and sensitivity information corresponding to the
+ equality constraints, `b_eq`. A dictionary consisting of the
+ fields:
+
+ residual : np.ndarray
+ The (nominally zero) residuals of the equality constraints,
+ ``b_eq - A_eq @ x``.
+
+ marginals : np.ndarray
+ The sensitivity (partial derivative) of the objective
+ function with respect to the right-hand side of the
+ equality constraints, `b_eq`.
+
+ lower, upper : OptimizeResult
+ Solution and sensitivity information corresponding to the
+ lower and upper bounds on decision variables, `bounds`.
+
+ residual : np.ndarray
+ The (nominally positive) values of the quantity
+ ``x - lb`` (lower) or ``ub - x`` (upper).
+
+ marginals : np.ndarray
+ The sensitivity (partial derivative) of the objective
+ function with respect to the lower and upper
+ `bounds`.
+
+ mip_node_count : int
+ The number of subproblems or "nodes" solved by the MILP
+ solver. Only present when `integrality` is not `None`.
+
+ mip_dual_bound : float
+ The MILP solver's final estimate of the lower bound on the
+ optimal solution. Only present when `integrality` is not
+ `None`.
+
+ mip_gap : float
+ The difference between the final objective function value
+ and the final dual bound, scaled by the final objective
+ function value. Only present when `integrality` is not
+ `None`.
+
+ Notes
+ -----
+ The result fields `ineqlin`, `eqlin`, `lower`, and `upper` all contain
+ `marginals`, or partial derivatives of the objective function with respect
+ to the right-hand side of each constraint. These partial derivatives are
+ also referred to as "Lagrange multipliers", "dual values", and
+ "shadow prices". The sign convention of `marginals` is opposite that
+ of Lagrange multipliers produced by many nonlinear solvers.
+
+ References
+ ----------
+ .. [15] Harris, Paula MJ. "Pivot selection methods of the Devex LP code."
+ Mathematical programming 5.1 (1973): 1-28.
+ .. [16] Goldfarb, Donald, and John Ker Reid. "A practicable steepest-edge
+ simplex algorithm." Mathematical Programming 12.1 (1977): 361-371.
+ """
+ if unknown_options:
+ message = (f"Unrecognized options detected: {unknown_options}. "
+ "These will be passed to HiGHS verbatim.")
+ warn(message, OptimizeWarning, stacklevel=3)
+
+ # Map options to HiGHS enum values
+ simplex_dual_edge_weight_strategy_enum = _convert_to_highs_enum(
+ simplex_dual_edge_weight_strategy,
+ 'simplex_dual_edge_weight_strategy',
+ choices={'dantzig': HIGHS_SIMPLEX_EDGE_WEIGHT_STRATEGY_DANTZIG,
+ 'devex': HIGHS_SIMPLEX_EDGE_WEIGHT_STRATEGY_DEVEX,
+ 'steepest-devex': HIGHS_SIMPLEX_EDGE_WEIGHT_STRATEGY_CHOOSE,
+ 'steepest':
+ HIGHS_SIMPLEX_EDGE_WEIGHT_STRATEGY_STEEPEST_EDGE,
+ None: None})
+
+ c, A_ub, b_ub, A_eq, b_eq, bounds, x0, integrality = lp
+
+ lb, ub = bounds.T.copy() # separate bounds, copy->C-cntgs
+ # highs_wrapper solves LHS <= A*x <= RHS, not equality constraints
+ with np.errstate(invalid="ignore"):
+ lhs_ub = -np.ones_like(b_ub)*np.inf # LHS of UB constraints is -inf
+ rhs_ub = b_ub # RHS of UB constraints is b_ub
+ lhs_eq = b_eq # Equality constraint is inequality
+ rhs_eq = b_eq # constraint with LHS=RHS
+ lhs = np.concatenate((lhs_ub, lhs_eq))
+ rhs = np.concatenate((rhs_ub, rhs_eq))
+
+ if issparse(A_ub) or issparse(A_eq):
+ A = vstack((A_ub, A_eq))
+ else:
+ A = np.vstack((A_ub, A_eq))
+ A = csc_matrix(A)
+
+ options = {
+ 'presolve': presolve,
+ 'sense': HIGHS_OBJECTIVE_SENSE_MINIMIZE,
+ 'solver': solver,
+ 'time_limit': time_limit,
+ 'highs_debug_level': MESSAGE_LEVEL_NONE,
+ 'dual_feasibility_tolerance': dual_feasibility_tolerance,
+ 'ipm_optimality_tolerance': ipm_optimality_tolerance,
+ 'log_to_console': disp,
+ 'mip_max_nodes': mip_max_nodes,
+ 'output_flag': disp,
+ 'primal_feasibility_tolerance': primal_feasibility_tolerance,
+ 'simplex_dual_edge_weight_strategy':
+ simplex_dual_edge_weight_strategy_enum,
+ 'simplex_strategy': HIGHS_SIMPLEX_STRATEGY_DUAL,
+ 'simplex_crash_strategy': HIGHS_SIMPLEX_CRASH_STRATEGY_OFF,
+ 'ipm_iteration_limit': maxiter,
+ 'simplex_iteration_limit': maxiter,
+ 'mip_rel_gap': mip_rel_gap,
+ }
+ options.update(unknown_options)
+
+ # np.inf doesn't work; use very large constant
+ rhs = _replace_inf(rhs)
+ lhs = _replace_inf(lhs)
+ lb = _replace_inf(lb)
+ ub = _replace_inf(ub)
+
+ if integrality is None or np.sum(integrality) == 0:
+ integrality = np.empty(0)
+ else:
+ integrality = np.array(integrality)
+
+ res = _highs_wrapper(c, A.indptr, A.indices, A.data, lhs, rhs,
+ lb, ub, integrality.astype(np.uint8), options)
+
+ # HiGHS represents constraints as lhs/rhs, so
+ # Ax + s = b => Ax = b - s
+ # and we need to split up s by A_ub and A_eq
+ if 'slack' in res:
+ slack = res['slack']
+ con = np.array(slack[len(b_ub):])
+ slack = np.array(slack[:len(b_ub)])
+ else:
+ slack, con = None, None
+
+ # lagrange multipliers for equalities/inequalities and upper/lower bounds
+ if 'lambda' in res:
+ lamda = res['lambda']
+ marg_ineqlin = np.array(lamda[:len(b_ub)])
+ marg_eqlin = np.array(lamda[len(b_ub):])
+ marg_upper = np.array(res['marg_bnds'][1, :])
+ marg_lower = np.array(res['marg_bnds'][0, :])
+ else:
+ marg_ineqlin, marg_eqlin = None, None
+ marg_upper, marg_lower = None, None
+
+ # this needs to be updated if we start choosing the solver intelligently
+
+ # Convert to scipy-style status and message
+ highs_status = res.get('status', None)
+ highs_message = res.get('message', None)
+ status, message = _highs_to_scipy_status_message(highs_status,
+ highs_message)
+
+ x = np.array(res['x']) if 'x' in res else None
+ sol = {'x': x,
+ 'slack': slack,
+ 'con': con,
+ 'ineqlin': OptimizeResult({
+ 'residual': slack,
+ 'marginals': marg_ineqlin,
+ }),
+ 'eqlin': OptimizeResult({
+ 'residual': con,
+ 'marginals': marg_eqlin,
+ }),
+ 'lower': OptimizeResult({
+ 'residual': None if x is None else x - lb,
+ 'marginals': marg_lower,
+ }),
+ 'upper': OptimizeResult({
+ 'residual': None if x is None else ub - x,
+ 'marginals': marg_upper
+ }),
+ 'fun': res.get('fun'),
+ 'status': status,
+ 'success': res['status'] == MODEL_STATUS_OPTIMAL,
+ 'message': message,
+ 'nit': res.get('simplex_nit', 0) or res.get('ipm_nit', 0),
+ 'crossover_nit': res.get('crossover_nit'),
+ }
+
+ if np.any(x) and integrality is not None:
+ sol.update({
+ 'mip_node_count': res.get('mip_node_count', 0),
+ 'mip_dual_bound': res.get('mip_dual_bound', 0.0),
+ 'mip_gap': res.get('mip_gap', 0.0),
+ })
+
+ return sol
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/__pycache__/bvls.cpython-310.pyc b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/__pycache__/bvls.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5d532ffe22c4a7c3715d27160a442ba326f889a2
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/__pycache__/bvls.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/__pycache__/trf_linear.cpython-310.pyc b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/__pycache__/trf_linear.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bd0731110a24c2744817db531684880d419199eb
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/__pycache__/trf_linear.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/bvls.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/bvls.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f34ead4a1fc4edbb3c2ab50a204aa9a3cc21cff
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/bvls.py
@@ -0,0 +1,183 @@
+"""Bounded-variable least-squares algorithm."""
+import numpy as np
+from numpy.linalg import norm, lstsq
+from scipy.optimize import OptimizeResult
+
+from .common import print_header_linear, print_iteration_linear
+
+
+def compute_kkt_optimality(g, on_bound):
+ """Compute the maximum violation of KKT conditions."""
+ g_kkt = g * on_bound
+ free_set = on_bound == 0
+ g_kkt[free_set] = np.abs(g[free_set])
+ return np.max(g_kkt)
+
+
+def bvls(A, b, x_lsq, lb, ub, tol, max_iter, verbose, rcond=None):
+ m, n = A.shape
+
+ x = x_lsq.copy()
+ on_bound = np.zeros(n)
+
+ mask = x <= lb
+ x[mask] = lb[mask]
+ on_bound[mask] = -1
+
+ mask = x >= ub
+ x[mask] = ub[mask]
+ on_bound[mask] = 1
+
+ free_set = on_bound == 0
+ active_set = ~free_set
+ free_set, = np.nonzero(free_set)
+
+ r = A.dot(x) - b
+ cost = 0.5 * np.dot(r, r)
+ initial_cost = cost
+ g = A.T.dot(r)
+
+ cost_change = None
+ step_norm = None
+ iteration = 0
+
+ if verbose == 2:
+ print_header_linear()
+
+ # This is the initialization loop. The requirement is that the
+ # least-squares solution on free variables is feasible before BVLS starts.
+ # One possible initialization is to set all variables to lower or upper
+ # bounds, but many iterations may be required from this state later on.
+ # The implemented ad-hoc procedure which intuitively should give a better
+ # initial state: find the least-squares solution on current free variables,
+ # if its feasible then stop, otherwise, set violating variables to
+ # corresponding bounds and continue on the reduced set of free variables.
+
+ while free_set.size > 0:
+ if verbose == 2:
+ optimality = compute_kkt_optimality(g, on_bound)
+ print_iteration_linear(iteration, cost, cost_change, step_norm,
+ optimality)
+
+ iteration += 1
+ x_free_old = x[free_set].copy()
+
+ A_free = A[:, free_set]
+ b_free = b - A.dot(x * active_set)
+ z = lstsq(A_free, b_free, rcond=rcond)[0]
+
+ lbv = z < lb[free_set]
+ ubv = z > ub[free_set]
+ v = lbv | ubv
+
+ if np.any(lbv):
+ ind = free_set[lbv]
+ x[ind] = lb[ind]
+ active_set[ind] = True
+ on_bound[ind] = -1
+
+ if np.any(ubv):
+ ind = free_set[ubv]
+ x[ind] = ub[ind]
+ active_set[ind] = True
+ on_bound[ind] = 1
+
+ ind = free_set[~v]
+ x[ind] = z[~v]
+
+ r = A.dot(x) - b
+ cost_new = 0.5 * np.dot(r, r)
+ cost_change = cost - cost_new
+ cost = cost_new
+ g = A.T.dot(r)
+ step_norm = norm(x[free_set] - x_free_old)
+
+ if np.any(v):
+ free_set = free_set[~v]
+ else:
+ break
+
+ if max_iter is None:
+ max_iter = n
+ max_iter += iteration
+
+ termination_status = None
+
+ # Main BVLS loop.
+
+ optimality = compute_kkt_optimality(g, on_bound)
+ for iteration in range(iteration, max_iter): # BVLS Loop A
+ if verbose == 2:
+ print_iteration_linear(iteration, cost, cost_change,
+ step_norm, optimality)
+
+ if optimality < tol:
+ termination_status = 1
+
+ if termination_status is not None:
+ break
+
+ move_to_free = np.argmax(g * on_bound)
+ on_bound[move_to_free] = 0
+
+ while True: # BVLS Loop B
+
+ free_set = on_bound == 0
+ active_set = ~free_set
+ free_set, = np.nonzero(free_set)
+
+ x_free = x[free_set]
+ x_free_old = x_free.copy()
+ lb_free = lb[free_set]
+ ub_free = ub[free_set]
+
+ A_free = A[:, free_set]
+ b_free = b - A.dot(x * active_set)
+ z = lstsq(A_free, b_free, rcond=rcond)[0]
+
+ lbv, = np.nonzero(z < lb_free)
+ ubv, = np.nonzero(z > ub_free)
+ v = np.hstack((lbv, ubv))
+
+ if v.size > 0:
+ alphas = np.hstack((
+ lb_free[lbv] - x_free[lbv],
+ ub_free[ubv] - x_free[ubv])) / (z[v] - x_free[v])
+
+ i = np.argmin(alphas)
+ i_free = v[i]
+ alpha = alphas[i]
+
+ x_free *= 1 - alpha
+ x_free += alpha * z
+ x[free_set] = x_free
+
+ if i < lbv.size:
+ on_bound[free_set[i_free]] = -1
+ else:
+ on_bound[free_set[i_free]] = 1
+ else:
+ x_free = z
+ x[free_set] = x_free
+ break
+
+ step_norm = norm(x_free - x_free_old)
+
+ r = A.dot(x) - b
+ cost_new = 0.5 * np.dot(r, r)
+ cost_change = cost - cost_new
+
+ if cost_change < tol * cost:
+ termination_status = 2
+ cost = cost_new
+
+ g = A.T.dot(r)
+ optimality = compute_kkt_optimality(g, on_bound)
+
+ if termination_status is None:
+ termination_status = 0
+
+ return OptimizeResult(
+ x=x, fun=r, cost=cost, optimality=optimality, active_mask=on_bound,
+ nit=iteration + 1, status=termination_status,
+ initial_cost=initial_cost)
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/common.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/common.py
new file mode 100644
index 0000000000000000000000000000000000000000..995c3b64ea64670463083ae41ba038f61338cdef
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/common.py
@@ -0,0 +1,733 @@
+"""Functions used by least-squares algorithms."""
+from math import copysign
+
+import numpy as np
+from numpy.linalg import norm
+
+from scipy.linalg import cho_factor, cho_solve, LinAlgError
+from scipy.sparse import issparse
+from scipy.sparse.linalg import LinearOperator, aslinearoperator
+
+
+EPS = np.finfo(float).eps
+
+
+# Functions related to a trust-region problem.
+
+
+def intersect_trust_region(x, s, Delta):
+ """Find the intersection of a line with the boundary of a trust region.
+
+ This function solves the quadratic equation with respect to t
+ ||(x + s*t)||**2 = Delta**2.
+
+ Returns
+ -------
+ t_neg, t_pos : tuple of float
+ Negative and positive roots.
+
+ Raises
+ ------
+ ValueError
+ If `s` is zero or `x` is not within the trust region.
+ """
+ a = np.dot(s, s)
+ if a == 0:
+ raise ValueError("`s` is zero.")
+
+ b = np.dot(x, s)
+
+ c = np.dot(x, x) - Delta**2
+ if c > 0:
+ raise ValueError("`x` is not within the trust region.")
+
+ d = np.sqrt(b*b - a*c) # Root from one fourth of the discriminant.
+
+ # Computations below avoid loss of significance, see "Numerical Recipes".
+ q = -(b + copysign(d, b))
+ t1 = q / a
+ t2 = c / q
+
+ if t1 < t2:
+ return t1, t2
+ else:
+ return t2, t1
+
+
+def solve_lsq_trust_region(n, m, uf, s, V, Delta, initial_alpha=None,
+ rtol=0.01, max_iter=10):
+ """Solve a trust-region problem arising in least-squares minimization.
+
+ This function implements a method described by J. J. More [1]_ and used
+ in MINPACK, but it relies on a single SVD of Jacobian instead of series
+ of Cholesky decompositions. Before running this function, compute:
+ ``U, s, VT = svd(J, full_matrices=False)``.
+
+ Parameters
+ ----------
+ n : int
+ Number of variables.
+ m : int
+ Number of residuals.
+ uf : ndarray
+ Computed as U.T.dot(f).
+ s : ndarray
+ Singular values of J.
+ V : ndarray
+ Transpose of VT.
+ Delta : float
+ Radius of a trust region.
+ initial_alpha : float, optional
+ Initial guess for alpha, which might be available from a previous
+ iteration. If None, determined automatically.
+ rtol : float, optional
+ Stopping tolerance for the root-finding procedure. Namely, the
+ solution ``p`` will satisfy ``abs(norm(p) - Delta) < rtol * Delta``.
+ max_iter : int, optional
+ Maximum allowed number of iterations for the root-finding procedure.
+
+ Returns
+ -------
+ p : ndarray, shape (n,)
+ Found solution of a trust-region problem.
+ alpha : float
+ Positive value such that (J.T*J + alpha*I)*p = -J.T*f.
+ Sometimes called Levenberg-Marquardt parameter.
+ n_iter : int
+ Number of iterations made by root-finding procedure. Zero means
+ that Gauss-Newton step was selected as the solution.
+
+ References
+ ----------
+ .. [1] More, J. J., "The Levenberg-Marquardt Algorithm: Implementation
+ and Theory," Numerical Analysis, ed. G. A. Watson, Lecture Notes
+ in Mathematics 630, Springer Verlag, pp. 105-116, 1977.
+ """
+ def phi_and_derivative(alpha, suf, s, Delta):
+ """Function of which to find zero.
+
+ It is defined as "norm of regularized (by alpha) least-squares
+ solution minus `Delta`". Refer to [1]_.
+ """
+ denom = s**2 + alpha
+ p_norm = norm(suf / denom)
+ phi = p_norm - Delta
+ phi_prime = -np.sum(suf ** 2 / denom**3) / p_norm
+ return phi, phi_prime
+
+ suf = s * uf
+
+ # Check if J has full rank and try Gauss-Newton step.
+ if m >= n:
+ threshold = EPS * m * s[0]
+ full_rank = s[-1] > threshold
+ else:
+ full_rank = False
+
+ if full_rank:
+ p = -V.dot(uf / s)
+ if norm(p) <= Delta:
+ return p, 0.0, 0
+
+ alpha_upper = norm(suf) / Delta
+
+ if full_rank:
+ phi, phi_prime = phi_and_derivative(0.0, suf, s, Delta)
+ alpha_lower = -phi / phi_prime
+ else:
+ alpha_lower = 0.0
+
+ if initial_alpha is None or not full_rank and initial_alpha == 0:
+ alpha = max(0.001 * alpha_upper, (alpha_lower * alpha_upper)**0.5)
+ else:
+ alpha = initial_alpha
+
+ for it in range(max_iter):
+ if alpha < alpha_lower or alpha > alpha_upper:
+ alpha = max(0.001 * alpha_upper, (alpha_lower * alpha_upper)**0.5)
+
+ phi, phi_prime = phi_and_derivative(alpha, suf, s, Delta)
+
+ if phi < 0:
+ alpha_upper = alpha
+
+ ratio = phi / phi_prime
+ alpha_lower = max(alpha_lower, alpha - ratio)
+ alpha -= (phi + Delta) * ratio / Delta
+
+ if np.abs(phi) < rtol * Delta:
+ break
+
+ p = -V.dot(suf / (s**2 + alpha))
+
+ # Make the norm of p equal to Delta, p is changed only slightly during
+ # this. It is done to prevent p lie outside the trust region (which can
+ # cause problems later).
+ p *= Delta / norm(p)
+
+ return p, alpha, it + 1
+
+
+def solve_trust_region_2d(B, g, Delta):
+ """Solve a general trust-region problem in 2 dimensions.
+
+ The problem is reformulated as a 4th order algebraic equation,
+ the solution of which is found by numpy.roots.
+
+ Parameters
+ ----------
+ B : ndarray, shape (2, 2)
+ Symmetric matrix, defines a quadratic term of the function.
+ g : ndarray, shape (2,)
+ Defines a linear term of the function.
+ Delta : float
+ Radius of a trust region.
+
+ Returns
+ -------
+ p : ndarray, shape (2,)
+ Found solution.
+ newton_step : bool
+ Whether the returned solution is the Newton step which lies within
+ the trust region.
+ """
+ try:
+ R, lower = cho_factor(B)
+ p = -cho_solve((R, lower), g)
+ if np.dot(p, p) <= Delta**2:
+ return p, True
+ except LinAlgError:
+ pass
+
+ a = B[0, 0] * Delta**2
+ b = B[0, 1] * Delta**2
+ c = B[1, 1] * Delta**2
+
+ d = g[0] * Delta
+ f = g[1] * Delta
+
+ coeffs = np.array(
+ [-b + d, 2 * (a - c + f), 6 * b, 2 * (-a + c + f), -b - d])
+ t = np.roots(coeffs) # Can handle leading zeros.
+ t = np.real(t[np.isreal(t)])
+
+ p = Delta * np.vstack((2 * t / (1 + t**2), (1 - t**2) / (1 + t**2)))
+ value = 0.5 * np.sum(p * B.dot(p), axis=0) + np.dot(g, p)
+ i = np.argmin(value)
+ p = p[:, i]
+
+ return p, False
+
+
+def update_tr_radius(Delta, actual_reduction, predicted_reduction,
+ step_norm, bound_hit):
+ """Update the radius of a trust region based on the cost reduction.
+
+ Returns
+ -------
+ Delta : float
+ New radius.
+ ratio : float
+ Ratio between actual and predicted reductions.
+ """
+ if predicted_reduction > 0:
+ ratio = actual_reduction / predicted_reduction
+ elif predicted_reduction == actual_reduction == 0:
+ ratio = 1
+ else:
+ ratio = 0
+
+ if ratio < 0.25:
+ Delta = 0.25 * step_norm
+ elif ratio > 0.75 and bound_hit:
+ Delta *= 2.0
+
+ return Delta, ratio
+
+
+# Construction and minimization of quadratic functions.
+
+
+def build_quadratic_1d(J, g, s, diag=None, s0=None):
+ """Parameterize a multivariate quadratic function along a line.
+
+ The resulting univariate quadratic function is given as follows::
+
+ f(t) = 0.5 * (s0 + s*t).T * (J.T*J + diag) * (s0 + s*t) +
+ g.T * (s0 + s*t)
+
+ Parameters
+ ----------
+ J : ndarray, sparse matrix or LinearOperator shape (m, n)
+ Jacobian matrix, affects the quadratic term.
+ g : ndarray, shape (n,)
+ Gradient, defines the linear term.
+ s : ndarray, shape (n,)
+ Direction vector of a line.
+ diag : None or ndarray with shape (n,), optional
+ Addition diagonal part, affects the quadratic term.
+ If None, assumed to be 0.
+ s0 : None or ndarray with shape (n,), optional
+ Initial point. If None, assumed to be 0.
+
+ Returns
+ -------
+ a : float
+ Coefficient for t**2.
+ b : float
+ Coefficient for t.
+ c : float
+ Free term. Returned only if `s0` is provided.
+ """
+ v = J.dot(s)
+ a = np.dot(v, v)
+ if diag is not None:
+ a += np.dot(s * diag, s)
+ a *= 0.5
+
+ b = np.dot(g, s)
+
+ if s0 is not None:
+ u = J.dot(s0)
+ b += np.dot(u, v)
+ c = 0.5 * np.dot(u, u) + np.dot(g, s0)
+ if diag is not None:
+ b += np.dot(s0 * diag, s)
+ c += 0.5 * np.dot(s0 * diag, s0)
+ return a, b, c
+ else:
+ return a, b
+
+
+def minimize_quadratic_1d(a, b, lb, ub, c=0):
+ """Minimize a 1-D quadratic function subject to bounds.
+
+ The free term `c` is 0 by default. Bounds must be finite.
+
+ Returns
+ -------
+ t : float
+ Minimum point.
+ y : float
+ Minimum value.
+ """
+ t = [lb, ub]
+ if a != 0:
+ extremum = -0.5 * b / a
+ if lb < extremum < ub:
+ t.append(extremum)
+ t = np.asarray(t)
+ y = t * (a * t + b) + c
+ min_index = np.argmin(y)
+ return t[min_index], y[min_index]
+
+
+def evaluate_quadratic(J, g, s, diag=None):
+ """Compute values of a quadratic function arising in least squares.
+
+ The function is 0.5 * s.T * (J.T * J + diag) * s + g.T * s.
+
+ Parameters
+ ----------
+ J : ndarray, sparse matrix or LinearOperator, shape (m, n)
+ Jacobian matrix, affects the quadratic term.
+ g : ndarray, shape (n,)
+ Gradient, defines the linear term.
+ s : ndarray, shape (k, n) or (n,)
+ Array containing steps as rows.
+ diag : ndarray, shape (n,), optional
+ Addition diagonal part, affects the quadratic term.
+ If None, assumed to be 0.
+
+ Returns
+ -------
+ values : ndarray with shape (k,) or float
+ Values of the function. If `s` was 2-D, then ndarray is
+ returned, otherwise, float is returned.
+ """
+ if s.ndim == 1:
+ Js = J.dot(s)
+ q = np.dot(Js, Js)
+ if diag is not None:
+ q += np.dot(s * diag, s)
+ else:
+ Js = J.dot(s.T)
+ q = np.sum(Js**2, axis=0)
+ if diag is not None:
+ q += np.sum(diag * s**2, axis=1)
+
+ l = np.dot(s, g)
+
+ return 0.5 * q + l
+
+
+# Utility functions to work with bound constraints.
+
+
+def in_bounds(x, lb, ub):
+ """Check if a point lies within bounds."""
+ return np.all((x >= lb) & (x <= ub))
+
+
+def step_size_to_bound(x, s, lb, ub):
+ """Compute a min_step size required to reach a bound.
+
+ The function computes a positive scalar t, such that x + s * t is on
+ the bound.
+
+ Returns
+ -------
+ step : float
+ Computed step. Non-negative value.
+ hits : ndarray of int with shape of x
+ Each element indicates whether a corresponding variable reaches the
+ bound:
+
+ * 0 - the bound was not hit.
+ * -1 - the lower bound was hit.
+ * 1 - the upper bound was hit.
+ """
+ non_zero = np.nonzero(s)
+ s_non_zero = s[non_zero]
+ steps = np.empty_like(x)
+ steps.fill(np.inf)
+ with np.errstate(over='ignore'):
+ steps[non_zero] = np.maximum((lb - x)[non_zero] / s_non_zero,
+ (ub - x)[non_zero] / s_non_zero)
+ min_step = np.min(steps)
+ return min_step, np.equal(steps, min_step) * np.sign(s).astype(int)
+
+
+def find_active_constraints(x, lb, ub, rtol=1e-10):
+ """Determine which constraints are active in a given point.
+
+ The threshold is computed using `rtol` and the absolute value of the
+ closest bound.
+
+ Returns
+ -------
+ active : ndarray of int with shape of x
+ Each component shows whether the corresponding constraint is active:
+
+ * 0 - a constraint is not active.
+ * -1 - a lower bound is active.
+ * 1 - a upper bound is active.
+ """
+ active = np.zeros_like(x, dtype=int)
+
+ if rtol == 0:
+ active[x <= lb] = -1
+ active[x >= ub] = 1
+ return active
+
+ lower_dist = x - lb
+ upper_dist = ub - x
+
+ lower_threshold = rtol * np.maximum(1, np.abs(lb))
+ upper_threshold = rtol * np.maximum(1, np.abs(ub))
+
+ lower_active = (np.isfinite(lb) &
+ (lower_dist <= np.minimum(upper_dist, lower_threshold)))
+ active[lower_active] = -1
+
+ upper_active = (np.isfinite(ub) &
+ (upper_dist <= np.minimum(lower_dist, upper_threshold)))
+ active[upper_active] = 1
+
+ return active
+
+
+def make_strictly_feasible(x, lb, ub, rstep=1e-10):
+ """Shift a point to the interior of a feasible region.
+
+ Each element of the returned vector is at least at a relative distance
+ `rstep` from the closest bound. If ``rstep=0`` then `np.nextafter` is used.
+ """
+ x_new = x.copy()
+
+ active = find_active_constraints(x, lb, ub, rstep)
+ lower_mask = np.equal(active, -1)
+ upper_mask = np.equal(active, 1)
+
+ if rstep == 0:
+ x_new[lower_mask] = np.nextafter(lb[lower_mask], ub[lower_mask])
+ x_new[upper_mask] = np.nextafter(ub[upper_mask], lb[upper_mask])
+ else:
+ x_new[lower_mask] = (lb[lower_mask] +
+ rstep * np.maximum(1, np.abs(lb[lower_mask])))
+ x_new[upper_mask] = (ub[upper_mask] -
+ rstep * np.maximum(1, np.abs(ub[upper_mask])))
+
+ tight_bounds = (x_new < lb) | (x_new > ub)
+ x_new[tight_bounds] = 0.5 * (lb[tight_bounds] + ub[tight_bounds])
+
+ return x_new
+
+
+def CL_scaling_vector(x, g, lb, ub):
+ """Compute Coleman-Li scaling vector and its derivatives.
+
+ Components of a vector v are defined as follows::
+
+ | ub[i] - x[i], if g[i] < 0 and ub[i] < np.inf
+ v[i] = | x[i] - lb[i], if g[i] > 0 and lb[i] > -np.inf
+ | 1, otherwise
+
+ According to this definition v[i] >= 0 for all i. It differs from the
+ definition in paper [1]_ (eq. (2.2)), where the absolute value of v is
+ used. Both definitions are equivalent down the line.
+ Derivatives of v with respect to x take value 1, -1 or 0 depending on a
+ case.
+
+ Returns
+ -------
+ v : ndarray with shape of x
+ Scaling vector.
+ dv : ndarray with shape of x
+ Derivatives of v[i] with respect to x[i], diagonal elements of v's
+ Jacobian.
+
+ References
+ ----------
+ .. [1] M.A. Branch, T.F. Coleman, and Y. Li, "A Subspace, Interior,
+ and Conjugate Gradient Method for Large-Scale Bound-Constrained
+ Minimization Problems," SIAM Journal on Scientific Computing,
+ Vol. 21, Number 1, pp 1-23, 1999.
+ """
+ v = np.ones_like(x)
+ dv = np.zeros_like(x)
+
+ mask = (g < 0) & np.isfinite(ub)
+ v[mask] = ub[mask] - x[mask]
+ dv[mask] = -1
+
+ mask = (g > 0) & np.isfinite(lb)
+ v[mask] = x[mask] - lb[mask]
+ dv[mask] = 1
+
+ return v, dv
+
+
+def reflective_transformation(y, lb, ub):
+ """Compute reflective transformation and its gradient."""
+ if in_bounds(y, lb, ub):
+ return y, np.ones_like(y)
+
+ lb_finite = np.isfinite(lb)
+ ub_finite = np.isfinite(ub)
+
+ x = y.copy()
+ g_negative = np.zeros_like(y, dtype=bool)
+
+ mask = lb_finite & ~ub_finite
+ x[mask] = np.maximum(y[mask], 2 * lb[mask] - y[mask])
+ g_negative[mask] = y[mask] < lb[mask]
+
+ mask = ~lb_finite & ub_finite
+ x[mask] = np.minimum(y[mask], 2 * ub[mask] - y[mask])
+ g_negative[mask] = y[mask] > ub[mask]
+
+ mask = lb_finite & ub_finite
+ d = ub - lb
+ t = np.remainder(y[mask] - lb[mask], 2 * d[mask])
+ x[mask] = lb[mask] + np.minimum(t, 2 * d[mask] - t)
+ g_negative[mask] = t > d[mask]
+
+ g = np.ones_like(y)
+ g[g_negative] = -1
+
+ return x, g
+
+
+# Functions to display algorithm's progress.
+
+
+def print_header_nonlinear():
+ print("{:^15}{:^15}{:^15}{:^15}{:^15}{:^15}"
+ .format("Iteration", "Total nfev", "Cost", "Cost reduction",
+ "Step norm", "Optimality"))
+
+
+def print_iteration_nonlinear(iteration, nfev, cost, cost_reduction,
+ step_norm, optimality):
+ if cost_reduction is None:
+ cost_reduction = " " * 15
+ else:
+ cost_reduction = f"{cost_reduction:^15.2e}"
+
+ if step_norm is None:
+ step_norm = " " * 15
+ else:
+ step_norm = f"{step_norm:^15.2e}"
+
+ print("{:^15}{:^15}{:^15.4e}{}{}{:^15.2e}"
+ .format(iteration, nfev, cost, cost_reduction,
+ step_norm, optimality))
+
+
+def print_header_linear():
+ print("{:^15}{:^15}{:^15}{:^15}{:^15}"
+ .format("Iteration", "Cost", "Cost reduction", "Step norm",
+ "Optimality"))
+
+
+def print_iteration_linear(iteration, cost, cost_reduction, step_norm,
+ optimality):
+ if cost_reduction is None:
+ cost_reduction = " " * 15
+ else:
+ cost_reduction = f"{cost_reduction:^15.2e}"
+
+ if step_norm is None:
+ step_norm = " " * 15
+ else:
+ step_norm = f"{step_norm:^15.2e}"
+
+ print(f"{iteration:^15}{cost:^15.4e}{cost_reduction}{step_norm}{optimality:^15.2e}")
+
+
+# Simple helper functions.
+
+
+def compute_grad(J, f):
+ """Compute gradient of the least-squares cost function."""
+ if isinstance(J, LinearOperator):
+ return J.rmatvec(f)
+ else:
+ return J.T.dot(f)
+
+
+def compute_jac_scale(J, scale_inv_old=None):
+ """Compute variables scale based on the Jacobian matrix."""
+ if issparse(J):
+ scale_inv = np.asarray(J.power(2).sum(axis=0)).ravel()**0.5
+ else:
+ scale_inv = np.sum(J**2, axis=0)**0.5
+
+ if scale_inv_old is None:
+ scale_inv[scale_inv == 0] = 1
+ else:
+ scale_inv = np.maximum(scale_inv, scale_inv_old)
+
+ return 1 / scale_inv, scale_inv
+
+
+def left_multiplied_operator(J, d):
+ """Return diag(d) J as LinearOperator."""
+ J = aslinearoperator(J)
+
+ def matvec(x):
+ return d * J.matvec(x)
+
+ def matmat(X):
+ return d[:, np.newaxis] * J.matmat(X)
+
+ def rmatvec(x):
+ return J.rmatvec(x.ravel() * d)
+
+ return LinearOperator(J.shape, matvec=matvec, matmat=matmat,
+ rmatvec=rmatvec)
+
+
+def right_multiplied_operator(J, d):
+ """Return J diag(d) as LinearOperator."""
+ J = aslinearoperator(J)
+
+ def matvec(x):
+ return J.matvec(np.ravel(x) * d)
+
+ def matmat(X):
+ return J.matmat(X * d[:, np.newaxis])
+
+ def rmatvec(x):
+ return d * J.rmatvec(x)
+
+ return LinearOperator(J.shape, matvec=matvec, matmat=matmat,
+ rmatvec=rmatvec)
+
+
+def regularized_lsq_operator(J, diag):
+ """Return a matrix arising in regularized least squares as LinearOperator.
+
+ The matrix is
+ [ J ]
+ [ D ]
+ where D is diagonal matrix with elements from `diag`.
+ """
+ J = aslinearoperator(J)
+ m, n = J.shape
+
+ def matvec(x):
+ return np.hstack((J.matvec(x), diag * x))
+
+ def rmatvec(x):
+ x1 = x[:m]
+ x2 = x[m:]
+ return J.rmatvec(x1) + diag * x2
+
+ return LinearOperator((m + n, n), matvec=matvec, rmatvec=rmatvec)
+
+
+def right_multiply(J, d, copy=True):
+ """Compute J diag(d).
+
+ If `copy` is False, `J` is modified in place (unless being LinearOperator).
+ """
+ if copy and not isinstance(J, LinearOperator):
+ J = J.copy()
+
+ if issparse(J):
+ J.data *= d.take(J.indices, mode='clip') # scikit-learn recipe.
+ elif isinstance(J, LinearOperator):
+ J = right_multiplied_operator(J, d)
+ else:
+ J *= d
+
+ return J
+
+
+def left_multiply(J, d, copy=True):
+ """Compute diag(d) J.
+
+ If `copy` is False, `J` is modified in place (unless being LinearOperator).
+ """
+ if copy and not isinstance(J, LinearOperator):
+ J = J.copy()
+
+ if issparse(J):
+ J.data *= np.repeat(d, np.diff(J.indptr)) # scikit-learn recipe.
+ elif isinstance(J, LinearOperator):
+ J = left_multiplied_operator(J, d)
+ else:
+ J *= d[:, np.newaxis]
+
+ return J
+
+
+def check_termination(dF, F, dx_norm, x_norm, ratio, ftol, xtol):
+ """Check termination condition for nonlinear least squares."""
+ ftol_satisfied = dF < ftol * F and ratio > 0.25
+ xtol_satisfied = dx_norm < xtol * (xtol + x_norm)
+
+ if ftol_satisfied and xtol_satisfied:
+ return 4
+ elif ftol_satisfied:
+ return 2
+ elif xtol_satisfied:
+ return 3
+ else:
+ return None
+
+
+def scale_for_robust_loss_function(J, f, rho):
+ """Scale Jacobian and residuals for a robust loss function.
+
+ Arrays are modified in place.
+ """
+ J_scale = rho[1] + 2 * rho[2] * f**2
+ J_scale[J_scale < EPS] = EPS
+ J_scale **= 0.5
+
+ f *= rho[1] / J_scale
+
+ return left_multiply(J, J_scale, copy=False), f
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/dogbox.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/dogbox.py
new file mode 100644
index 0000000000000000000000000000000000000000..6bb5abbe79028afed7b110603a0d5dfd6affae7f
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/dogbox.py
@@ -0,0 +1,331 @@
+"""
+Dogleg algorithm with rectangular trust regions for least-squares minimization.
+
+The description of the algorithm can be found in [Voglis]_. The algorithm does
+trust-region iterations, but the shape of trust regions is rectangular as
+opposed to conventional elliptical. The intersection of a trust region and
+an initial feasible region is again some rectangle. Thus, on each iteration a
+bound-constrained quadratic optimization problem is solved.
+
+A quadratic problem is solved by well-known dogleg approach, where the
+function is minimized along piecewise-linear "dogleg" path [NumOpt]_,
+Chapter 4. If Jacobian is not rank-deficient then the function is decreasing
+along this path, and optimization amounts to simply following along this
+path as long as a point stays within the bounds. A constrained Cauchy step
+(along the anti-gradient) is considered for safety in rank deficient cases,
+in this situations the convergence might be slow.
+
+If during iterations some variable hit the initial bound and the component
+of anti-gradient points outside the feasible region, then a next dogleg step
+won't make any progress. At this state such variables satisfy first-order
+optimality conditions and they are excluded before computing a next dogleg
+step.
+
+Gauss-Newton step can be computed exactly by `numpy.linalg.lstsq` (for dense
+Jacobian matrices) or by iterative procedure `scipy.sparse.linalg.lsmr` (for
+dense and sparse matrices, or Jacobian being LinearOperator). The second
+option allows to solve very large problems (up to couple of millions of
+residuals on a regular PC), provided the Jacobian matrix is sufficiently
+sparse. But note that dogbox is not very good for solving problems with
+large number of constraints, because of variables exclusion-inclusion on each
+iteration (a required number of function evaluations might be high or accuracy
+of a solution will be poor), thus its large-scale usage is probably limited
+to unconstrained problems.
+
+References
+----------
+.. [Voglis] C. Voglis and I. E. Lagaris, "A Rectangular Trust Region Dogleg
+ Approach for Unconstrained and Bound Constrained Nonlinear
+ Optimization", WSEAS International Conference on Applied
+ Mathematics, Corfu, Greece, 2004.
+.. [NumOpt] J. Nocedal and S. J. Wright, "Numerical optimization, 2nd edition".
+"""
+import numpy as np
+from numpy.linalg import lstsq, norm
+
+from scipy.sparse.linalg import LinearOperator, aslinearoperator, lsmr
+from scipy.optimize import OptimizeResult
+
+from .common import (
+ step_size_to_bound, in_bounds, update_tr_radius, evaluate_quadratic,
+ build_quadratic_1d, minimize_quadratic_1d, compute_grad,
+ compute_jac_scale, check_termination, scale_for_robust_loss_function,
+ print_header_nonlinear, print_iteration_nonlinear)
+
+
+def lsmr_operator(Jop, d, active_set):
+ """Compute LinearOperator to use in LSMR by dogbox algorithm.
+
+ `active_set` mask is used to excluded active variables from computations
+ of matrix-vector products.
+ """
+ m, n = Jop.shape
+
+ def matvec(x):
+ x_free = x.ravel().copy()
+ x_free[active_set] = 0
+ return Jop.matvec(x * d)
+
+ def rmatvec(x):
+ r = d * Jop.rmatvec(x)
+ r[active_set] = 0
+ return r
+
+ return LinearOperator((m, n), matvec=matvec, rmatvec=rmatvec, dtype=float)
+
+
+def find_intersection(x, tr_bounds, lb, ub):
+ """Find intersection of trust-region bounds and initial bounds.
+
+ Returns
+ -------
+ lb_total, ub_total : ndarray with shape of x
+ Lower and upper bounds of the intersection region.
+ orig_l, orig_u : ndarray of bool with shape of x
+ True means that an original bound is taken as a corresponding bound
+ in the intersection region.
+ tr_l, tr_u : ndarray of bool with shape of x
+ True means that a trust-region bound is taken as a corresponding bound
+ in the intersection region.
+ """
+ lb_centered = lb - x
+ ub_centered = ub - x
+
+ lb_total = np.maximum(lb_centered, -tr_bounds)
+ ub_total = np.minimum(ub_centered, tr_bounds)
+
+ orig_l = np.equal(lb_total, lb_centered)
+ orig_u = np.equal(ub_total, ub_centered)
+
+ tr_l = np.equal(lb_total, -tr_bounds)
+ tr_u = np.equal(ub_total, tr_bounds)
+
+ return lb_total, ub_total, orig_l, orig_u, tr_l, tr_u
+
+
+def dogleg_step(x, newton_step, g, a, b, tr_bounds, lb, ub):
+ """Find dogleg step in a rectangular region.
+
+ Returns
+ -------
+ step : ndarray, shape (n,)
+ Computed dogleg step.
+ bound_hits : ndarray of int, shape (n,)
+ Each component shows whether a corresponding variable hits the
+ initial bound after the step is taken:
+ * 0 - a variable doesn't hit the bound.
+ * -1 - lower bound is hit.
+ * 1 - upper bound is hit.
+ tr_hit : bool
+ Whether the step hit the boundary of the trust-region.
+ """
+ lb_total, ub_total, orig_l, orig_u, tr_l, tr_u = find_intersection(
+ x, tr_bounds, lb, ub
+ )
+ bound_hits = np.zeros_like(x, dtype=int)
+
+ if in_bounds(newton_step, lb_total, ub_total):
+ return newton_step, bound_hits, False
+
+ to_bounds, _ = step_size_to_bound(np.zeros_like(x), -g, lb_total, ub_total)
+
+ # The classical dogleg algorithm would check if Cauchy step fits into
+ # the bounds, and just return it constrained version if not. But in a
+ # rectangular trust region it makes sense to try to improve constrained
+ # Cauchy step too. Thus, we don't distinguish these two cases.
+
+ cauchy_step = -minimize_quadratic_1d(a, b, 0, to_bounds)[0] * g
+
+ step_diff = newton_step - cauchy_step
+ step_size, hits = step_size_to_bound(cauchy_step, step_diff,
+ lb_total, ub_total)
+ bound_hits[(hits < 0) & orig_l] = -1
+ bound_hits[(hits > 0) & orig_u] = 1
+ tr_hit = np.any((hits < 0) & tr_l | (hits > 0) & tr_u)
+
+ return cauchy_step + step_size * step_diff, bound_hits, tr_hit
+
+
+def dogbox(fun, jac, x0, f0, J0, lb, ub, ftol, xtol, gtol, max_nfev, x_scale,
+ loss_function, tr_solver, tr_options, verbose):
+ f = f0
+ f_true = f.copy()
+ nfev = 1
+
+ J = J0
+ njev = 1
+
+ if loss_function is not None:
+ rho = loss_function(f)
+ cost = 0.5 * np.sum(rho[0])
+ J, f = scale_for_robust_loss_function(J, f, rho)
+ else:
+ cost = 0.5 * np.dot(f, f)
+
+ g = compute_grad(J, f)
+
+ jac_scale = isinstance(x_scale, str) and x_scale == 'jac'
+ if jac_scale:
+ scale, scale_inv = compute_jac_scale(J)
+ else:
+ scale, scale_inv = x_scale, 1 / x_scale
+
+ Delta = norm(x0 * scale_inv, ord=np.inf)
+ if Delta == 0:
+ Delta = 1.0
+
+ on_bound = np.zeros_like(x0, dtype=int)
+ on_bound[np.equal(x0, lb)] = -1
+ on_bound[np.equal(x0, ub)] = 1
+
+ x = x0
+ step = np.empty_like(x0)
+
+ if max_nfev is None:
+ max_nfev = x0.size * 100
+
+ termination_status = None
+ iteration = 0
+ step_norm = None
+ actual_reduction = None
+
+ if verbose == 2:
+ print_header_nonlinear()
+
+ while True:
+ active_set = on_bound * g < 0
+ free_set = ~active_set
+
+ g_free = g[free_set]
+ g_full = g.copy()
+ g[active_set] = 0
+
+ g_norm = norm(g, ord=np.inf)
+ if g_norm < gtol:
+ termination_status = 1
+
+ if verbose == 2:
+ print_iteration_nonlinear(iteration, nfev, cost, actual_reduction,
+ step_norm, g_norm)
+
+ if termination_status is not None or nfev == max_nfev:
+ break
+
+ x_free = x[free_set]
+ lb_free = lb[free_set]
+ ub_free = ub[free_set]
+ scale_free = scale[free_set]
+
+ # Compute (Gauss-)Newton and build quadratic model for Cauchy step.
+ if tr_solver == 'exact':
+ J_free = J[:, free_set]
+ newton_step = lstsq(J_free, -f, rcond=-1)[0]
+
+ # Coefficients for the quadratic model along the anti-gradient.
+ a, b = build_quadratic_1d(J_free, g_free, -g_free)
+ elif tr_solver == 'lsmr':
+ Jop = aslinearoperator(J)
+
+ # We compute lsmr step in scaled variables and then
+ # transform back to normal variables, if lsmr would give exact lsq
+ # solution, this would be equivalent to not doing any
+ # transformations, but from experience it's better this way.
+
+ # We pass active_set to make computations as if we selected
+ # the free subset of J columns, but without actually doing any
+ # slicing, which is expensive for sparse matrices and impossible
+ # for LinearOperator.
+
+ lsmr_op = lsmr_operator(Jop, scale, active_set)
+ newton_step = -lsmr(lsmr_op, f, **tr_options)[0][free_set]
+ newton_step *= scale_free
+
+ # Components of g for active variables were zeroed, so this call
+ # is correct and equivalent to using J_free and g_free.
+ a, b = build_quadratic_1d(Jop, g, -g)
+
+ actual_reduction = -1.0
+ while actual_reduction <= 0 and nfev < max_nfev:
+ tr_bounds = Delta * scale_free
+
+ step_free, on_bound_free, tr_hit = dogleg_step(
+ x_free, newton_step, g_free, a, b, tr_bounds, lb_free, ub_free)
+
+ step.fill(0.0)
+ step[free_set] = step_free
+
+ if tr_solver == 'exact':
+ predicted_reduction = -evaluate_quadratic(J_free, g_free,
+ step_free)
+ elif tr_solver == 'lsmr':
+ predicted_reduction = -evaluate_quadratic(Jop, g, step)
+
+ # gh11403 ensure that solution is fully within bounds.
+ x_new = np.clip(x + step, lb, ub)
+
+ f_new = fun(x_new)
+ nfev += 1
+
+ step_h_norm = norm(step * scale_inv, ord=np.inf)
+
+ if not np.all(np.isfinite(f_new)):
+ Delta = 0.25 * step_h_norm
+ continue
+
+ # Usual trust-region step quality estimation.
+ if loss_function is not None:
+ cost_new = loss_function(f_new, cost_only=True)
+ else:
+ cost_new = 0.5 * np.dot(f_new, f_new)
+ actual_reduction = cost - cost_new
+
+ Delta, ratio = update_tr_radius(
+ Delta, actual_reduction, predicted_reduction,
+ step_h_norm, tr_hit
+ )
+
+ step_norm = norm(step)
+ termination_status = check_termination(
+ actual_reduction, cost, step_norm, norm(x), ratio, ftol, xtol)
+
+ if termination_status is not None:
+ break
+
+ if actual_reduction > 0:
+ on_bound[free_set] = on_bound_free
+
+ x = x_new
+ # Set variables exactly at the boundary.
+ mask = on_bound == -1
+ x[mask] = lb[mask]
+ mask = on_bound == 1
+ x[mask] = ub[mask]
+
+ f = f_new
+ f_true = f.copy()
+
+ cost = cost_new
+
+ J = jac(x, f)
+ njev += 1
+
+ if loss_function is not None:
+ rho = loss_function(f)
+ J, f = scale_for_robust_loss_function(J, f, rho)
+
+ g = compute_grad(J, f)
+
+ if jac_scale:
+ scale, scale_inv = compute_jac_scale(J, scale_inv)
+ else:
+ step_norm = 0
+ actual_reduction = 0
+
+ iteration += 1
+
+ if termination_status is None:
+ termination_status = 0
+
+ return OptimizeResult(
+ x=x, cost=cost, fun=f_true, jac=J, grad=g_full, optimality=g_norm,
+ active_mask=on_bound, nfev=nfev, njev=njev, status=termination_status)
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/least_squares.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/least_squares.py
new file mode 100644
index 0000000000000000000000000000000000000000..db8bb31c7b1530fd48ac7ae58cf501e2b0081a91
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/least_squares.py
@@ -0,0 +1,967 @@
+"""Generic interface for least-squares minimization."""
+from warnings import warn
+
+import numpy as np
+from numpy.linalg import norm
+
+from scipy.sparse import issparse
+from scipy.sparse.linalg import LinearOperator
+from scipy.optimize import _minpack, OptimizeResult
+from scipy.optimize._numdiff import approx_derivative, group_columns
+from scipy.optimize._minimize import Bounds
+
+from .trf import trf
+from .dogbox import dogbox
+from .common import EPS, in_bounds, make_strictly_feasible
+
+
+TERMINATION_MESSAGES = {
+ -1: "Improper input parameters status returned from `leastsq`",
+ 0: "The maximum number of function evaluations is exceeded.",
+ 1: "`gtol` termination condition is satisfied.",
+ 2: "`ftol` termination condition is satisfied.",
+ 3: "`xtol` termination condition is satisfied.",
+ 4: "Both `ftol` and `xtol` termination conditions are satisfied."
+}
+
+
+FROM_MINPACK_TO_COMMON = {
+ 0: -1, # Improper input parameters from MINPACK.
+ 1: 2,
+ 2: 3,
+ 3: 4,
+ 4: 1,
+ 5: 0
+ # There are 6, 7, 8 for too small tolerance parameters,
+ # but we guard against it by checking ftol, xtol, gtol beforehand.
+}
+
+
+def call_minpack(fun, x0, jac, ftol, xtol, gtol, max_nfev, x_scale, diff_step):
+ n = x0.size
+
+ if diff_step is None:
+ epsfcn = EPS
+ else:
+ epsfcn = diff_step**2
+
+ # Compute MINPACK's `diag`, which is inverse of our `x_scale` and
+ # ``x_scale='jac'`` corresponds to ``diag=None``.
+ if isinstance(x_scale, str) and x_scale == 'jac':
+ diag = None
+ else:
+ diag = 1 / x_scale
+
+ full_output = True
+ col_deriv = False
+ factor = 100.0
+
+ if jac is None:
+ if max_nfev is None:
+ # n squared to account for Jacobian evaluations.
+ max_nfev = 100 * n * (n + 1)
+ x, info, status = _minpack._lmdif(
+ fun, x0, (), full_output, ftol, xtol, gtol,
+ max_nfev, epsfcn, factor, diag)
+ else:
+ if max_nfev is None:
+ max_nfev = 100 * n
+ x, info, status = _minpack._lmder(
+ fun, jac, x0, (), full_output, col_deriv,
+ ftol, xtol, gtol, max_nfev, factor, diag)
+
+ f = info['fvec']
+
+ if callable(jac):
+ J = jac(x)
+ else:
+ J = np.atleast_2d(approx_derivative(fun, x))
+
+ cost = 0.5 * np.dot(f, f)
+ g = J.T.dot(f)
+ g_norm = norm(g, ord=np.inf)
+
+ nfev = info['nfev']
+ njev = info.get('njev', None)
+
+ status = FROM_MINPACK_TO_COMMON[status]
+ active_mask = np.zeros_like(x0, dtype=int)
+
+ return OptimizeResult(
+ x=x, cost=cost, fun=f, jac=J, grad=g, optimality=g_norm,
+ active_mask=active_mask, nfev=nfev, njev=njev, status=status)
+
+
+def prepare_bounds(bounds, n):
+ lb, ub = (np.asarray(b, dtype=float) for b in bounds)
+ if lb.ndim == 0:
+ lb = np.resize(lb, n)
+
+ if ub.ndim == 0:
+ ub = np.resize(ub, n)
+
+ return lb, ub
+
+
+def check_tolerance(ftol, xtol, gtol, method):
+ def check(tol, name):
+ if tol is None:
+ tol = 0
+ elif tol < EPS:
+ warn(f"Setting `{name}` below the machine epsilon ({EPS:.2e}) effectively "
+ f"disables the corresponding termination condition.",
+ stacklevel=3)
+ return tol
+
+ ftol = check(ftol, "ftol")
+ xtol = check(xtol, "xtol")
+ gtol = check(gtol, "gtol")
+
+ if method == "lm" and (ftol < EPS or xtol < EPS or gtol < EPS):
+ raise ValueError("All tolerances must be higher than machine epsilon "
+ f"({EPS:.2e}) for method 'lm'.")
+ elif ftol < EPS and xtol < EPS and gtol < EPS:
+ raise ValueError("At least one of the tolerances must be higher than "
+ f"machine epsilon ({EPS:.2e}).")
+
+ return ftol, xtol, gtol
+
+
+def check_x_scale(x_scale, x0):
+ if isinstance(x_scale, str) and x_scale == 'jac':
+ return x_scale
+
+ try:
+ x_scale = np.asarray(x_scale, dtype=float)
+ valid = np.all(np.isfinite(x_scale)) and np.all(x_scale > 0)
+ except (ValueError, TypeError):
+ valid = False
+
+ if not valid:
+ raise ValueError("`x_scale` must be 'jac' or array_like with "
+ "positive numbers.")
+
+ if x_scale.ndim == 0:
+ x_scale = np.resize(x_scale, x0.shape)
+
+ if x_scale.shape != x0.shape:
+ raise ValueError("Inconsistent shapes between `x_scale` and `x0`.")
+
+ return x_scale
+
+
+def check_jac_sparsity(jac_sparsity, m, n):
+ if jac_sparsity is None:
+ return None
+
+ if not issparse(jac_sparsity):
+ jac_sparsity = np.atleast_2d(jac_sparsity)
+
+ if jac_sparsity.shape != (m, n):
+ raise ValueError("`jac_sparsity` has wrong shape.")
+
+ return jac_sparsity, group_columns(jac_sparsity)
+
+
+# Loss functions.
+
+
+def huber(z, rho, cost_only):
+ mask = z <= 1
+ rho[0, mask] = z[mask]
+ rho[0, ~mask] = 2 * z[~mask]**0.5 - 1
+ if cost_only:
+ return
+ rho[1, mask] = 1
+ rho[1, ~mask] = z[~mask]**-0.5
+ rho[2, mask] = 0
+ rho[2, ~mask] = -0.5 * z[~mask]**-1.5
+
+
+def soft_l1(z, rho, cost_only):
+ t = 1 + z
+ rho[0] = 2 * (t**0.5 - 1)
+ if cost_only:
+ return
+ rho[1] = t**-0.5
+ rho[2] = -0.5 * t**-1.5
+
+
+def cauchy(z, rho, cost_only):
+ rho[0] = np.log1p(z)
+ if cost_only:
+ return
+ t = 1 + z
+ rho[1] = 1 / t
+ rho[2] = -1 / t**2
+
+
+def arctan(z, rho, cost_only):
+ rho[0] = np.arctan(z)
+ if cost_only:
+ return
+ t = 1 + z**2
+ rho[1] = 1 / t
+ rho[2] = -2 * z / t**2
+
+
+IMPLEMENTED_LOSSES = dict(linear=None, huber=huber, soft_l1=soft_l1,
+ cauchy=cauchy, arctan=arctan)
+
+
+def construct_loss_function(m, loss, f_scale):
+ if loss == 'linear':
+ return None
+
+ if not callable(loss):
+ loss = IMPLEMENTED_LOSSES[loss]
+ rho = np.empty((3, m))
+
+ def loss_function(f, cost_only=False):
+ z = (f / f_scale) ** 2
+ loss(z, rho, cost_only=cost_only)
+ if cost_only:
+ return 0.5 * f_scale ** 2 * np.sum(rho[0])
+ rho[0] *= f_scale ** 2
+ rho[2] /= f_scale ** 2
+ return rho
+ else:
+ def loss_function(f, cost_only=False):
+ z = (f / f_scale) ** 2
+ rho = loss(z)
+ if cost_only:
+ return 0.5 * f_scale ** 2 * np.sum(rho[0])
+ rho[0] *= f_scale ** 2
+ rho[2] /= f_scale ** 2
+ return rho
+
+ return loss_function
+
+
+def least_squares(
+ fun, x0, jac='2-point', bounds=(-np.inf, np.inf), method='trf',
+ ftol=1e-8, xtol=1e-8, gtol=1e-8, x_scale=1.0, loss='linear',
+ f_scale=1.0, diff_step=None, tr_solver=None, tr_options={},
+ jac_sparsity=None, max_nfev=None, verbose=0, args=(), kwargs={}):
+ """Solve a nonlinear least-squares problem with bounds on the variables.
+
+ Given the residuals f(x) (an m-D real function of n real
+ variables) and the loss function rho(s) (a scalar function), `least_squares`
+ finds a local minimum of the cost function F(x)::
+
+ minimize F(x) = 0.5 * sum(rho(f_i(x)**2), i = 0, ..., m - 1)
+ subject to lb <= x <= ub
+
+ The purpose of the loss function rho(s) is to reduce the influence of
+ outliers on the solution.
+
+ Parameters
+ ----------
+ fun : callable
+ Function which computes the vector of residuals, with the signature
+ ``fun(x, *args, **kwargs)``, i.e., the minimization proceeds with
+ respect to its first argument. The argument ``x`` passed to this
+ function is an ndarray of shape (n,) (never a scalar, even for n=1).
+ It must allocate and return a 1-D array_like of shape (m,) or a scalar.
+ If the argument ``x`` is complex or the function ``fun`` returns
+ complex residuals, it must be wrapped in a real function of real
+ arguments, as shown at the end of the Examples section.
+ x0 : array_like with shape (n,) or float
+ Initial guess on independent variables. If float, it will be treated
+ as a 1-D array with one element. When `method` is 'trf', the initial
+ guess might be slightly adjusted to lie sufficiently within the given
+ `bounds`.
+ jac : {'2-point', '3-point', 'cs', callable}, optional
+ Method of computing the Jacobian matrix (an m-by-n matrix, where
+ element (i, j) is the partial derivative of f[i] with respect to
+ x[j]). The keywords select a finite difference scheme for numerical
+ estimation. The scheme '3-point' is more accurate, but requires
+ twice as many operations as '2-point' (default). The scheme 'cs'
+ uses complex steps, and while potentially the most accurate, it is
+ applicable only when `fun` correctly handles complex inputs and
+ can be analytically continued to the complex plane. Method 'lm'
+ always uses the '2-point' scheme. If callable, it is used as
+ ``jac(x, *args, **kwargs)`` and should return a good approximation
+ (or the exact value) for the Jacobian as an array_like (np.atleast_2d
+ is applied), a sparse matrix (csr_matrix preferred for performance) or
+ a `scipy.sparse.linalg.LinearOperator`.
+ bounds : 2-tuple of array_like or `Bounds`, optional
+ There are two ways to specify bounds:
+
+ 1. Instance of `Bounds` class
+ 2. Lower and upper bounds on independent variables. Defaults to no
+ bounds. Each array must match the size of `x0` or be a scalar,
+ in the latter case a bound will be the same for all variables.
+ Use ``np.inf`` with an appropriate sign to disable bounds on all
+ or some variables.
+ method : {'trf', 'dogbox', 'lm'}, optional
+ Algorithm to perform minimization.
+
+ * 'trf' : Trust Region Reflective algorithm, particularly suitable
+ for large sparse problems with bounds. Generally robust method.
+ * 'dogbox' : dogleg algorithm with rectangular trust regions,
+ typical use case is small problems with bounds. Not recommended
+ for problems with rank-deficient Jacobian.
+ * 'lm' : Levenberg-Marquardt algorithm as implemented in MINPACK.
+ Doesn't handle bounds and sparse Jacobians. Usually the most
+ efficient method for small unconstrained problems.
+
+ Default is 'trf'. See Notes for more information.
+ ftol : float or None, optional
+ Tolerance for termination by the change of the cost function. Default
+ is 1e-8. The optimization process is stopped when ``dF < ftol * F``,
+ and there was an adequate agreement between a local quadratic model and
+ the true model in the last step.
+
+ If None and 'method' is not 'lm', the termination by this condition is
+ disabled. If 'method' is 'lm', this tolerance must be higher than
+ machine epsilon.
+ xtol : float or None, optional
+ Tolerance for termination by the change of the independent variables.
+ Default is 1e-8. The exact condition depends on the `method` used:
+
+ * For 'trf' and 'dogbox' : ``norm(dx) < xtol * (xtol + norm(x))``.
+ * For 'lm' : ``Delta < xtol * norm(xs)``, where ``Delta`` is
+ a trust-region radius and ``xs`` is the value of ``x``
+ scaled according to `x_scale` parameter (see below).
+
+ If None and 'method' is not 'lm', the termination by this condition is
+ disabled. If 'method' is 'lm', this tolerance must be higher than
+ machine epsilon.
+ gtol : float or None, optional
+ Tolerance for termination by the norm of the gradient. Default is 1e-8.
+ The exact condition depends on a `method` used:
+
+ * For 'trf' : ``norm(g_scaled, ord=np.inf) < gtol``, where
+ ``g_scaled`` is the value of the gradient scaled to account for
+ the presence of the bounds [STIR]_.
+ * For 'dogbox' : ``norm(g_free, ord=np.inf) < gtol``, where
+ ``g_free`` is the gradient with respect to the variables which
+ are not in the optimal state on the boundary.
+ * For 'lm' : the maximum absolute value of the cosine of angles
+ between columns of the Jacobian and the residual vector is less
+ than `gtol`, or the residual vector is zero.
+
+ If None and 'method' is not 'lm', the termination by this condition is
+ disabled. If 'method' is 'lm', this tolerance must be higher than
+ machine epsilon.
+ x_scale : array_like or 'jac', optional
+ Characteristic scale of each variable. Setting `x_scale` is equivalent
+ to reformulating the problem in scaled variables ``xs = x / x_scale``.
+ An alternative view is that the size of a trust region along jth
+ dimension is proportional to ``x_scale[j]``. Improved convergence may
+ be achieved by setting `x_scale` such that a step of a given size
+ along any of the scaled variables has a similar effect on the cost
+ function. If set to 'jac', the scale is iteratively updated using the
+ inverse norms of the columns of the Jacobian matrix (as described in
+ [JJMore]_).
+ loss : str or callable, optional
+ Determines the loss function. The following keyword values are allowed:
+
+ * 'linear' (default) : ``rho(z) = z``. Gives a standard
+ least-squares problem.
+ * 'soft_l1' : ``rho(z) = 2 * ((1 + z)**0.5 - 1)``. The smooth
+ approximation of l1 (absolute value) loss. Usually a good
+ choice for robust least squares.
+ * 'huber' : ``rho(z) = z if z <= 1 else 2*z**0.5 - 1``. Works
+ similarly to 'soft_l1'.
+ * 'cauchy' : ``rho(z) = ln(1 + z)``. Severely weakens outliers
+ influence, but may cause difficulties in optimization process.
+ * 'arctan' : ``rho(z) = arctan(z)``. Limits a maximum loss on
+ a single residual, has properties similar to 'cauchy'.
+
+ If callable, it must take a 1-D ndarray ``z=f**2`` and return an
+ array_like with shape (3, m) where row 0 contains function values,
+ row 1 contains first derivatives and row 2 contains second
+ derivatives. Method 'lm' supports only 'linear' loss.
+ f_scale : float, optional
+ Value of soft margin between inlier and outlier residuals, default
+ is 1.0. The loss function is evaluated as follows
+ ``rho_(f**2) = C**2 * rho(f**2 / C**2)``, where ``C`` is `f_scale`,
+ and ``rho`` is determined by `loss` parameter. This parameter has
+ no effect with ``loss='linear'``, but for other `loss` values it is
+ of crucial importance.
+ max_nfev : None or int, optional
+ Maximum number of function evaluations before the termination.
+ If None (default), the value is chosen automatically:
+
+ * For 'trf' and 'dogbox' : 100 * n.
+ * For 'lm' : 100 * n if `jac` is callable and 100 * n * (n + 1)
+ otherwise (because 'lm' counts function calls in Jacobian
+ estimation).
+
+ diff_step : None or array_like, optional
+ Determines the relative step size for the finite difference
+ approximation of the Jacobian. The actual step is computed as
+ ``x * diff_step``. If None (default), then `diff_step` is taken to be
+ a conventional "optimal" power of machine epsilon for the finite
+ difference scheme used [NR]_.
+ tr_solver : {None, 'exact', 'lsmr'}, optional
+ Method for solving trust-region subproblems, relevant only for 'trf'
+ and 'dogbox' methods.
+
+ * 'exact' is suitable for not very large problems with dense
+ Jacobian matrices. The computational complexity per iteration is
+ comparable to a singular value decomposition of the Jacobian
+ matrix.
+ * 'lsmr' is suitable for problems with sparse and large Jacobian
+ matrices. It uses the iterative procedure
+ `scipy.sparse.linalg.lsmr` for finding a solution of a linear
+ least-squares problem and only requires matrix-vector product
+ evaluations.
+
+ If None (default), the solver is chosen based on the type of Jacobian
+ returned on the first iteration.
+ tr_options : dict, optional
+ Keyword options passed to trust-region solver.
+
+ * ``tr_solver='exact'``: `tr_options` are ignored.
+ * ``tr_solver='lsmr'``: options for `scipy.sparse.linalg.lsmr`.
+ Additionally, ``method='trf'`` supports 'regularize' option
+ (bool, default is True), which adds a regularization term to the
+ normal equation, which improves convergence if the Jacobian is
+ rank-deficient [Byrd]_ (eq. 3.4).
+
+ jac_sparsity : {None, array_like, sparse matrix}, optional
+ Defines the sparsity structure of the Jacobian matrix for finite
+ difference estimation, its shape must be (m, n). If the Jacobian has
+ only few non-zero elements in *each* row, providing the sparsity
+ structure will greatly speed up the computations [Curtis]_. A zero
+ entry means that a corresponding element in the Jacobian is identically
+ zero. If provided, forces the use of 'lsmr' trust-region solver.
+ If None (default), then dense differencing will be used. Has no effect
+ for 'lm' method.
+ verbose : {0, 1, 2}, optional
+ Level of algorithm's verbosity:
+
+ * 0 (default) : work silently.
+ * 1 : display a termination report.
+ * 2 : display progress during iterations (not supported by 'lm'
+ method).
+
+ args, kwargs : tuple and dict, optional
+ Additional arguments passed to `fun` and `jac`. Both empty by default.
+ The calling signature is ``fun(x, *args, **kwargs)`` and the same for
+ `jac`.
+
+ Returns
+ -------
+ result : OptimizeResult
+ `OptimizeResult` with the following fields defined:
+
+ x : ndarray, shape (n,)
+ Solution found.
+ cost : float
+ Value of the cost function at the solution.
+ fun : ndarray, shape (m,)
+ Vector of residuals at the solution.
+ jac : ndarray, sparse matrix or LinearOperator, shape (m, n)
+ Modified Jacobian matrix at the solution, in the sense that J^T J
+ is a Gauss-Newton approximation of the Hessian of the cost function.
+ The type is the same as the one used by the algorithm.
+ grad : ndarray, shape (m,)
+ Gradient of the cost function at the solution.
+ optimality : float
+ First-order optimality measure. In unconstrained problems, it is
+ always the uniform norm of the gradient. In constrained problems,
+ it is the quantity which was compared with `gtol` during iterations.
+ active_mask : ndarray of int, shape (n,)
+ Each component shows whether a corresponding constraint is active
+ (that is, whether a variable is at the bound):
+
+ * 0 : a constraint is not active.
+ * -1 : a lower bound is active.
+ * 1 : an upper bound is active.
+
+ Might be somewhat arbitrary for 'trf' method as it generates a
+ sequence of strictly feasible iterates and `active_mask` is
+ determined within a tolerance threshold.
+ nfev : int
+ Number of function evaluations done. Methods 'trf' and 'dogbox' do
+ not count function calls for numerical Jacobian approximation, as
+ opposed to 'lm' method.
+ njev : int or None
+ Number of Jacobian evaluations done. If numerical Jacobian
+ approximation is used in 'lm' method, it is set to None.
+ status : int
+ The reason for algorithm termination:
+
+ * -1 : improper input parameters status returned from MINPACK.
+ * 0 : the maximum number of function evaluations is exceeded.
+ * 1 : `gtol` termination condition is satisfied.
+ * 2 : `ftol` termination condition is satisfied.
+ * 3 : `xtol` termination condition is satisfied.
+ * 4 : Both `ftol` and `xtol` termination conditions are satisfied.
+
+ message : str
+ Verbal description of the termination reason.
+ success : bool
+ True if one of the convergence criteria is satisfied (`status` > 0).
+
+ See Also
+ --------
+ leastsq : A legacy wrapper for the MINPACK implementation of the
+ Levenberg-Marquadt algorithm.
+ curve_fit : Least-squares minimization applied to a curve-fitting problem.
+
+ Notes
+ -----
+ Method 'lm' (Levenberg-Marquardt) calls a wrapper over least-squares
+ algorithms implemented in MINPACK (lmder, lmdif). It runs the
+ Levenberg-Marquardt algorithm formulated as a trust-region type algorithm.
+ The implementation is based on paper [JJMore]_, it is very robust and
+ efficient with a lot of smart tricks. It should be your first choice
+ for unconstrained problems. Note that it doesn't support bounds. Also,
+ it doesn't work when m < n.
+
+ Method 'trf' (Trust Region Reflective) is motivated by the process of
+ solving a system of equations, which constitute the first-order optimality
+ condition for a bound-constrained minimization problem as formulated in
+ [STIR]_. The algorithm iteratively solves trust-region subproblems
+ augmented by a special diagonal quadratic term and with trust-region shape
+ determined by the distance from the bounds and the direction of the
+ gradient. This enhancements help to avoid making steps directly into bounds
+ and efficiently explore the whole space of variables. To further improve
+ convergence, the algorithm considers search directions reflected from the
+ bounds. To obey theoretical requirements, the algorithm keeps iterates
+ strictly feasible. With dense Jacobians trust-region subproblems are
+ solved by an exact method very similar to the one described in [JJMore]_
+ (and implemented in MINPACK). The difference from the MINPACK
+ implementation is that a singular value decomposition of a Jacobian
+ matrix is done once per iteration, instead of a QR decomposition and series
+ of Givens rotation eliminations. For large sparse Jacobians a 2-D subspace
+ approach of solving trust-region subproblems is used [STIR]_, [Byrd]_.
+ The subspace is spanned by a scaled gradient and an approximate
+ Gauss-Newton solution delivered by `scipy.sparse.linalg.lsmr`. When no
+ constraints are imposed the algorithm is very similar to MINPACK and has
+ generally comparable performance. The algorithm works quite robust in
+ unbounded and bounded problems, thus it is chosen as a default algorithm.
+
+ Method 'dogbox' operates in a trust-region framework, but considers
+ rectangular trust regions as opposed to conventional ellipsoids [Voglis]_.
+ The intersection of a current trust region and initial bounds is again
+ rectangular, so on each iteration a quadratic minimization problem subject
+ to bound constraints is solved approximately by Powell's dogleg method
+ [NumOpt]_. The required Gauss-Newton step can be computed exactly for
+ dense Jacobians or approximately by `scipy.sparse.linalg.lsmr` for large
+ sparse Jacobians. The algorithm is likely to exhibit slow convergence when
+ the rank of Jacobian is less than the number of variables. The algorithm
+ often outperforms 'trf' in bounded problems with a small number of
+ variables.
+
+ Robust loss functions are implemented as described in [BA]_. The idea
+ is to modify a residual vector and a Jacobian matrix on each iteration
+ such that computed gradient and Gauss-Newton Hessian approximation match
+ the true gradient and Hessian approximation of the cost function. Then
+ the algorithm proceeds in a normal way, i.e., robust loss functions are
+ implemented as a simple wrapper over standard least-squares algorithms.
+
+ .. versionadded:: 0.17.0
+
+ References
+ ----------
+ .. [STIR] M. A. Branch, T. F. Coleman, and Y. Li, "A Subspace, Interior,
+ and Conjugate Gradient Method for Large-Scale Bound-Constrained
+ Minimization Problems," SIAM Journal on Scientific Computing,
+ Vol. 21, Number 1, pp 1-23, 1999.
+ .. [NR] William H. Press et. al., "Numerical Recipes. The Art of Scientific
+ Computing. 3rd edition", Sec. 5.7.
+ .. [Byrd] R. H. Byrd, R. B. Schnabel and G. A. Shultz, "Approximate
+ solution of the trust region problem by minimization over
+ two-dimensional subspaces", Math. Programming, 40, pp. 247-263,
+ 1988.
+ .. [Curtis] A. Curtis, M. J. D. Powell, and J. Reid, "On the estimation of
+ sparse Jacobian matrices", Journal of the Institute of
+ Mathematics and its Applications, 13, pp. 117-120, 1974.
+ .. [JJMore] J. J. More, "The Levenberg-Marquardt Algorithm: Implementation
+ and Theory," Numerical Analysis, ed. G. A. Watson, Lecture
+ Notes in Mathematics 630, Springer Verlag, pp. 105-116, 1977.
+ .. [Voglis] C. Voglis and I. E. Lagaris, "A Rectangular Trust Region
+ Dogleg Approach for Unconstrained and Bound Constrained
+ Nonlinear Optimization", WSEAS International Conference on
+ Applied Mathematics, Corfu, Greece, 2004.
+ .. [NumOpt] J. Nocedal and S. J. Wright, "Numerical optimization,
+ 2nd edition", Chapter 4.
+ .. [BA] B. Triggs et. al., "Bundle Adjustment - A Modern Synthesis",
+ Proceedings of the International Workshop on Vision Algorithms:
+ Theory and Practice, pp. 298-372, 1999.
+
+ Examples
+ --------
+ In this example we find a minimum of the Rosenbrock function without bounds
+ on independent variables.
+
+ >>> import numpy as np
+ >>> def fun_rosenbrock(x):
+ ... return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])
+
+ Notice that we only provide the vector of the residuals. The algorithm
+ constructs the cost function as a sum of squares of the residuals, which
+ gives the Rosenbrock function. The exact minimum is at ``x = [1.0, 1.0]``.
+
+ >>> from scipy.optimize import least_squares
+ >>> x0_rosenbrock = np.array([2, 2])
+ >>> res_1 = least_squares(fun_rosenbrock, x0_rosenbrock)
+ >>> res_1.x
+ array([ 1., 1.])
+ >>> res_1.cost
+ 9.8669242910846867e-30
+ >>> res_1.optimality
+ 8.8928864934219529e-14
+
+ We now constrain the variables, in such a way that the previous solution
+ becomes infeasible. Specifically, we require that ``x[1] >= 1.5``, and
+ ``x[0]`` left unconstrained. To this end, we specify the `bounds` parameter
+ to `least_squares` in the form ``bounds=([-np.inf, 1.5], np.inf)``.
+
+ We also provide the analytic Jacobian:
+
+ >>> def jac_rosenbrock(x):
+ ... return np.array([
+ ... [-20 * x[0], 10],
+ ... [-1, 0]])
+
+ Putting this all together, we see that the new solution lies on the bound:
+
+ >>> res_2 = least_squares(fun_rosenbrock, x0_rosenbrock, jac_rosenbrock,
+ ... bounds=([-np.inf, 1.5], np.inf))
+ >>> res_2.x
+ array([ 1.22437075, 1.5 ])
+ >>> res_2.cost
+ 0.025213093946805685
+ >>> res_2.optimality
+ 1.5885401433157753e-07
+
+ Now we solve a system of equations (i.e., the cost function should be zero
+ at a minimum) for a Broyden tridiagonal vector-valued function of 100000
+ variables:
+
+ >>> def fun_broyden(x):
+ ... f = (3 - x) * x + 1
+ ... f[1:] -= x[:-1]
+ ... f[:-1] -= 2 * x[1:]
+ ... return f
+
+ The corresponding Jacobian matrix is sparse. We tell the algorithm to
+ estimate it by finite differences and provide the sparsity structure of
+ Jacobian to significantly speed up this process.
+
+ >>> from scipy.sparse import lil_matrix
+ >>> def sparsity_broyden(n):
+ ... sparsity = lil_matrix((n, n), dtype=int)
+ ... i = np.arange(n)
+ ... sparsity[i, i] = 1
+ ... i = np.arange(1, n)
+ ... sparsity[i, i - 1] = 1
+ ... i = np.arange(n - 1)
+ ... sparsity[i, i + 1] = 1
+ ... return sparsity
+ ...
+ >>> n = 100000
+ >>> x0_broyden = -np.ones(n)
+ ...
+ >>> res_3 = least_squares(fun_broyden, x0_broyden,
+ ... jac_sparsity=sparsity_broyden(n))
+ >>> res_3.cost
+ 4.5687069299604613e-23
+ >>> res_3.optimality
+ 1.1650454296851518e-11
+
+ Let's also solve a curve fitting problem using robust loss function to
+ take care of outliers in the data. Define the model function as
+ ``y = a + b * exp(c * t)``, where t is a predictor variable, y is an
+ observation and a, b, c are parameters to estimate.
+
+ First, define the function which generates the data with noise and
+ outliers, define the model parameters, and generate data:
+
+ >>> from numpy.random import default_rng
+ >>> rng = default_rng()
+ >>> def gen_data(t, a, b, c, noise=0., n_outliers=0, seed=None):
+ ... rng = default_rng(seed)
+ ...
+ ... y = a + b * np.exp(t * c)
+ ...
+ ... error = noise * rng.standard_normal(t.size)
+ ... outliers = rng.integers(0, t.size, n_outliers)
+ ... error[outliers] *= 10
+ ...
+ ... return y + error
+ ...
+ >>> a = 0.5
+ >>> b = 2.0
+ >>> c = -1
+ >>> t_min = 0
+ >>> t_max = 10
+ >>> n_points = 15
+ ...
+ >>> t_train = np.linspace(t_min, t_max, n_points)
+ >>> y_train = gen_data(t_train, a, b, c, noise=0.1, n_outliers=3)
+
+ Define function for computing residuals and initial estimate of
+ parameters.
+
+ >>> def fun(x, t, y):
+ ... return x[0] + x[1] * np.exp(x[2] * t) - y
+ ...
+ >>> x0 = np.array([1.0, 1.0, 0.0])
+
+ Compute a standard least-squares solution:
+
+ >>> res_lsq = least_squares(fun, x0, args=(t_train, y_train))
+
+ Now compute two solutions with two different robust loss functions. The
+ parameter `f_scale` is set to 0.1, meaning that inlier residuals should
+ not significantly exceed 0.1 (the noise level used).
+
+ >>> res_soft_l1 = least_squares(fun, x0, loss='soft_l1', f_scale=0.1,
+ ... args=(t_train, y_train))
+ >>> res_log = least_squares(fun, x0, loss='cauchy', f_scale=0.1,
+ ... args=(t_train, y_train))
+
+ And, finally, plot all the curves. We see that by selecting an appropriate
+ `loss` we can get estimates close to optimal even in the presence of
+ strong outliers. But keep in mind that generally it is recommended to try
+ 'soft_l1' or 'huber' losses first (if at all necessary) as the other two
+ options may cause difficulties in optimization process.
+
+ >>> t_test = np.linspace(t_min, t_max, n_points * 10)
+ >>> y_true = gen_data(t_test, a, b, c)
+ >>> y_lsq = gen_data(t_test, *res_lsq.x)
+ >>> y_soft_l1 = gen_data(t_test, *res_soft_l1.x)
+ >>> y_log = gen_data(t_test, *res_log.x)
+ ...
+ >>> import matplotlib.pyplot as plt
+ >>> plt.plot(t_train, y_train, 'o')
+ >>> plt.plot(t_test, y_true, 'k', linewidth=2, label='true')
+ >>> plt.plot(t_test, y_lsq, label='linear loss')
+ >>> plt.plot(t_test, y_soft_l1, label='soft_l1 loss')
+ >>> plt.plot(t_test, y_log, label='cauchy loss')
+ >>> plt.xlabel("t")
+ >>> plt.ylabel("y")
+ >>> plt.legend()
+ >>> plt.show()
+
+ In the next example, we show how complex-valued residual functions of
+ complex variables can be optimized with ``least_squares()``. Consider the
+ following function:
+
+ >>> def f(z):
+ ... return z - (0.5 + 0.5j)
+
+ We wrap it into a function of real variables that returns real residuals
+ by simply handling the real and imaginary parts as independent variables:
+
+ >>> def f_wrap(x):
+ ... fx = f(x[0] + 1j*x[1])
+ ... return np.array([fx.real, fx.imag])
+
+ Thus, instead of the original m-D complex function of n complex
+ variables we optimize a 2m-D real function of 2n real variables:
+
+ >>> from scipy.optimize import least_squares
+ >>> res_wrapped = least_squares(f_wrap, (0.1, 0.1), bounds=([0, 0], [1, 1]))
+ >>> z = res_wrapped.x[0] + res_wrapped.x[1]*1j
+ >>> z
+ (0.49999999999925893+0.49999999999925893j)
+
+ """
+ if method not in ['trf', 'dogbox', 'lm']:
+ raise ValueError("`method` must be 'trf', 'dogbox' or 'lm'.")
+
+ if jac not in ['2-point', '3-point', 'cs'] and not callable(jac):
+ raise ValueError("`jac` must be '2-point', '3-point', 'cs' or "
+ "callable.")
+
+ if tr_solver not in [None, 'exact', 'lsmr']:
+ raise ValueError("`tr_solver` must be None, 'exact' or 'lsmr'.")
+
+ if loss not in IMPLEMENTED_LOSSES and not callable(loss):
+ raise ValueError("`loss` must be one of {} or a callable."
+ .format(IMPLEMENTED_LOSSES.keys()))
+
+ if method == 'lm' and loss != 'linear':
+ raise ValueError("method='lm' supports only 'linear' loss function.")
+
+ if verbose not in [0, 1, 2]:
+ raise ValueError("`verbose` must be in [0, 1, 2].")
+
+ if max_nfev is not None and max_nfev <= 0:
+ raise ValueError("`max_nfev` must be None or positive integer.")
+
+ if np.iscomplexobj(x0):
+ raise ValueError("`x0` must be real.")
+
+ x0 = np.atleast_1d(x0).astype(float)
+
+ if x0.ndim > 1:
+ raise ValueError("`x0` must have at most 1 dimension.")
+
+ if isinstance(bounds, Bounds):
+ lb, ub = bounds.lb, bounds.ub
+ bounds = (lb, ub)
+ else:
+ if len(bounds) == 2:
+ lb, ub = prepare_bounds(bounds, x0.shape[0])
+ else:
+ raise ValueError("`bounds` must contain 2 elements.")
+
+ if method == 'lm' and not np.all((lb == -np.inf) & (ub == np.inf)):
+ raise ValueError("Method 'lm' doesn't support bounds.")
+
+ if lb.shape != x0.shape or ub.shape != x0.shape:
+ raise ValueError("Inconsistent shapes between bounds and `x0`.")
+
+ if np.any(lb >= ub):
+ raise ValueError("Each lower bound must be strictly less than each "
+ "upper bound.")
+
+ if not in_bounds(x0, lb, ub):
+ raise ValueError("`x0` is infeasible.")
+
+ x_scale = check_x_scale(x_scale, x0)
+
+ ftol, xtol, gtol = check_tolerance(ftol, xtol, gtol, method)
+
+ if method == 'trf':
+ x0 = make_strictly_feasible(x0, lb, ub)
+
+ def fun_wrapped(x):
+ return np.atleast_1d(fun(x, *args, **kwargs))
+
+ f0 = fun_wrapped(x0)
+
+ if f0.ndim != 1:
+ raise ValueError("`fun` must return at most 1-d array_like. "
+ f"f0.shape: {f0.shape}")
+
+ if not np.all(np.isfinite(f0)):
+ raise ValueError("Residuals are not finite in the initial point.")
+
+ n = x0.size
+ m = f0.size
+
+ if method == 'lm' and m < n:
+ raise ValueError("Method 'lm' doesn't work when the number of "
+ "residuals is less than the number of variables.")
+
+ loss_function = construct_loss_function(m, loss, f_scale)
+ if callable(loss):
+ rho = loss_function(f0)
+ if rho.shape != (3, m):
+ raise ValueError("The return value of `loss` callable has wrong "
+ "shape.")
+ initial_cost = 0.5 * np.sum(rho[0])
+ elif loss_function is not None:
+ initial_cost = loss_function(f0, cost_only=True)
+ else:
+ initial_cost = 0.5 * np.dot(f0, f0)
+
+ if callable(jac):
+ J0 = jac(x0, *args, **kwargs)
+
+ if issparse(J0):
+ J0 = J0.tocsr()
+
+ def jac_wrapped(x, _=None):
+ return jac(x, *args, **kwargs).tocsr()
+
+ elif isinstance(J0, LinearOperator):
+ def jac_wrapped(x, _=None):
+ return jac(x, *args, **kwargs)
+
+ else:
+ J0 = np.atleast_2d(J0)
+
+ def jac_wrapped(x, _=None):
+ return np.atleast_2d(jac(x, *args, **kwargs))
+
+ else: # Estimate Jacobian by finite differences.
+ if method == 'lm':
+ if jac_sparsity is not None:
+ raise ValueError("method='lm' does not support "
+ "`jac_sparsity`.")
+
+ if jac != '2-point':
+ warn(f"jac='{jac}' works equivalently to '2-point' for method='lm'.",
+ stacklevel=2)
+
+ J0 = jac_wrapped = None
+ else:
+ if jac_sparsity is not None and tr_solver == 'exact':
+ raise ValueError("tr_solver='exact' is incompatible "
+ "with `jac_sparsity`.")
+
+ jac_sparsity = check_jac_sparsity(jac_sparsity, m, n)
+
+ def jac_wrapped(x, f):
+ J = approx_derivative(fun, x, rel_step=diff_step, method=jac,
+ f0=f, bounds=bounds, args=args,
+ kwargs=kwargs, sparsity=jac_sparsity)
+ if J.ndim != 2: # J is guaranteed not sparse.
+ J = np.atleast_2d(J)
+
+ return J
+
+ J0 = jac_wrapped(x0, f0)
+
+ if J0 is not None:
+ if J0.shape != (m, n):
+ raise ValueError(
+ f"The return value of `jac` has wrong shape: expected {(m, n)}, "
+ f"actual {J0.shape}."
+ )
+
+ if not isinstance(J0, np.ndarray):
+ if method == 'lm':
+ raise ValueError("method='lm' works only with dense "
+ "Jacobian matrices.")
+
+ if tr_solver == 'exact':
+ raise ValueError(
+ "tr_solver='exact' works only with dense "
+ "Jacobian matrices.")
+
+ jac_scale = isinstance(x_scale, str) and x_scale == 'jac'
+ if isinstance(J0, LinearOperator) and jac_scale:
+ raise ValueError("x_scale='jac' can't be used when `jac` "
+ "returns LinearOperator.")
+
+ if tr_solver is None:
+ if isinstance(J0, np.ndarray):
+ tr_solver = 'exact'
+ else:
+ tr_solver = 'lsmr'
+
+ if method == 'lm':
+ result = call_minpack(fun_wrapped, x0, jac_wrapped, ftol, xtol, gtol,
+ max_nfev, x_scale, diff_step)
+
+ elif method == 'trf':
+ result = trf(fun_wrapped, jac_wrapped, x0, f0, J0, lb, ub, ftol, xtol,
+ gtol, max_nfev, x_scale, loss_function, tr_solver,
+ tr_options.copy(), verbose)
+
+ elif method == 'dogbox':
+ if tr_solver == 'lsmr' and 'regularize' in tr_options:
+ warn("The keyword 'regularize' in `tr_options` is not relevant "
+ "for 'dogbox' method.",
+ stacklevel=2)
+ tr_options = tr_options.copy()
+ del tr_options['regularize']
+
+ result = dogbox(fun_wrapped, jac_wrapped, x0, f0, J0, lb, ub, ftol,
+ xtol, gtol, max_nfev, x_scale, loss_function,
+ tr_solver, tr_options, verbose)
+
+ result.message = TERMINATION_MESSAGES[result.status]
+ result.success = result.status > 0
+
+ if verbose >= 1:
+ print(result.message)
+ print("Function evaluations {}, initial cost {:.4e}, final cost "
+ "{:.4e}, first-order optimality {:.2e}."
+ .format(result.nfev, initial_cost, result.cost,
+ result.optimality))
+
+ return result
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/lsq_linear.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/lsq_linear.py
new file mode 100644
index 0000000000000000000000000000000000000000..fdf4d26020109d55a6aea2be3009181a388c722d
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/lsq_linear.py
@@ -0,0 +1,362 @@
+"""Linear least squares with bound constraints on independent variables."""
+import numpy as np
+from numpy.linalg import norm
+from scipy.sparse import issparse, csr_matrix
+from scipy.sparse.linalg import LinearOperator, lsmr
+from scipy.optimize import OptimizeResult
+from scipy.optimize._minimize import Bounds
+
+from .common import in_bounds, compute_grad
+from .trf_linear import trf_linear
+from .bvls import bvls
+
+
+def prepare_bounds(bounds, n):
+ if len(bounds) != 2:
+ raise ValueError("`bounds` must contain 2 elements.")
+ lb, ub = (np.asarray(b, dtype=float) for b in bounds)
+
+ if lb.ndim == 0:
+ lb = np.resize(lb, n)
+
+ if ub.ndim == 0:
+ ub = np.resize(ub, n)
+
+ return lb, ub
+
+
+TERMINATION_MESSAGES = {
+ -1: "The algorithm was not able to make progress on the last iteration.",
+ 0: "The maximum number of iterations is exceeded.",
+ 1: "The first-order optimality measure is less than `tol`.",
+ 2: "The relative change of the cost function is less than `tol`.",
+ 3: "The unconstrained solution is optimal."
+}
+
+
+def lsq_linear(A, b, bounds=(-np.inf, np.inf), method='trf', tol=1e-10,
+ lsq_solver=None, lsmr_tol=None, max_iter=None,
+ verbose=0, *, lsmr_maxiter=None,):
+ r"""Solve a linear least-squares problem with bounds on the variables.
+
+ Given a m-by-n design matrix A and a target vector b with m elements,
+ `lsq_linear` solves the following optimization problem::
+
+ minimize 0.5 * ||A x - b||**2
+ subject to lb <= x <= ub
+
+ This optimization problem is convex, hence a found minimum (if iterations
+ have converged) is guaranteed to be global.
+
+ Parameters
+ ----------
+ A : array_like, sparse matrix of LinearOperator, shape (m, n)
+ Design matrix. Can be `scipy.sparse.linalg.LinearOperator`.
+ b : array_like, shape (m,)
+ Target vector.
+ bounds : 2-tuple of array_like or `Bounds`, optional
+ Lower and upper bounds on parameters. Defaults to no bounds.
+ There are two ways to specify the bounds:
+
+ - Instance of `Bounds` class.
+
+ - 2-tuple of array_like: Each element of the tuple must be either
+ an array with the length equal to the number of parameters, or a
+ scalar (in which case the bound is taken to be the same for all
+ parameters). Use ``np.inf`` with an appropriate sign to disable
+ bounds on all or some parameters.
+
+ method : 'trf' or 'bvls', optional
+ Method to perform minimization.
+
+ * 'trf' : Trust Region Reflective algorithm adapted for a linear
+ least-squares problem. This is an interior-point-like method
+ and the required number of iterations is weakly correlated with
+ the number of variables.
+ * 'bvls' : Bounded-variable least-squares algorithm. This is
+ an active set method, which requires the number of iterations
+ comparable to the number of variables. Can't be used when `A` is
+ sparse or LinearOperator.
+
+ Default is 'trf'.
+ tol : float, optional
+ Tolerance parameter. The algorithm terminates if a relative change
+ of the cost function is less than `tol` on the last iteration.
+ Additionally, the first-order optimality measure is considered:
+
+ * ``method='trf'`` terminates if the uniform norm of the gradient,
+ scaled to account for the presence of the bounds, is less than
+ `tol`.
+ * ``method='bvls'`` terminates if Karush-Kuhn-Tucker conditions
+ are satisfied within `tol` tolerance.
+
+ lsq_solver : {None, 'exact', 'lsmr'}, optional
+ Method of solving unbounded least-squares problems throughout
+ iterations:
+
+ * 'exact' : Use dense QR or SVD decomposition approach. Can't be
+ used when `A` is sparse or LinearOperator.
+ * 'lsmr' : Use `scipy.sparse.linalg.lsmr` iterative procedure
+ which requires only matrix-vector product evaluations. Can't
+ be used with ``method='bvls'``.
+
+ If None (default), the solver is chosen based on type of `A`.
+ lsmr_tol : None, float or 'auto', optional
+ Tolerance parameters 'atol' and 'btol' for `scipy.sparse.linalg.lsmr`
+ If None (default), it is set to ``1e-2 * tol``. If 'auto', the
+ tolerance will be adjusted based on the optimality of the current
+ iterate, which can speed up the optimization process, but is not always
+ reliable.
+ max_iter : None or int, optional
+ Maximum number of iterations before termination. If None (default), it
+ is set to 100 for ``method='trf'`` or to the number of variables for
+ ``method='bvls'`` (not counting iterations for 'bvls' initialization).
+ verbose : {0, 1, 2}, optional
+ Level of algorithm's verbosity:
+
+ * 0 : work silently (default).
+ * 1 : display a termination report.
+ * 2 : display progress during iterations.
+ lsmr_maxiter : None or int, optional
+ Maximum number of iterations for the lsmr least squares solver,
+ if it is used (by setting ``lsq_solver='lsmr'``). If None (default), it
+ uses lsmr's default of ``min(m, n)`` where ``m`` and ``n`` are the
+ number of rows and columns of `A`, respectively. Has no effect if
+ ``lsq_solver='exact'``.
+
+ Returns
+ -------
+ OptimizeResult with the following fields defined:
+ x : ndarray, shape (n,)
+ Solution found.
+ cost : float
+ Value of the cost function at the solution.
+ fun : ndarray, shape (m,)
+ Vector of residuals at the solution.
+ optimality : float
+ First-order optimality measure. The exact meaning depends on `method`,
+ refer to the description of `tol` parameter.
+ active_mask : ndarray of int, shape (n,)
+ Each component shows whether a corresponding constraint is active
+ (that is, whether a variable is at the bound):
+
+ * 0 : a constraint is not active.
+ * -1 : a lower bound is active.
+ * 1 : an upper bound is active.
+
+ Might be somewhat arbitrary for the `trf` method as it generates a
+ sequence of strictly feasible iterates and active_mask is determined
+ within a tolerance threshold.
+ unbounded_sol : tuple
+ Unbounded least squares solution tuple returned by the least squares
+ solver (set with `lsq_solver` option). If `lsq_solver` is not set or is
+ set to ``'exact'``, the tuple contains an ndarray of shape (n,) with
+ the unbounded solution, an ndarray with the sum of squared residuals,
+ an int with the rank of `A`, and an ndarray with the singular values
+ of `A` (see NumPy's ``linalg.lstsq`` for more information). If
+ `lsq_solver` is set to ``'lsmr'``, the tuple contains an ndarray of
+ shape (n,) with the unbounded solution, an int with the exit code,
+ an int with the number of iterations, and five floats with
+ various norms and the condition number of `A` (see SciPy's
+ ``sparse.linalg.lsmr`` for more information). This output can be
+ useful for determining the convergence of the least squares solver,
+ particularly the iterative ``'lsmr'`` solver. The unbounded least
+ squares problem is to minimize ``0.5 * ||A x - b||**2``.
+ nit : int
+ Number of iterations. Zero if the unconstrained solution is optimal.
+ status : int
+ Reason for algorithm termination:
+
+ * -1 : the algorithm was not able to make progress on the last
+ iteration.
+ * 0 : the maximum number of iterations is exceeded.
+ * 1 : the first-order optimality measure is less than `tol`.
+ * 2 : the relative change of the cost function is less than `tol`.
+ * 3 : the unconstrained solution is optimal.
+
+ message : str
+ Verbal description of the termination reason.
+ success : bool
+ True if one of the convergence criteria is satisfied (`status` > 0).
+
+ See Also
+ --------
+ nnls : Linear least squares with non-negativity constraint.
+ least_squares : Nonlinear least squares with bounds on the variables.
+
+ Notes
+ -----
+ The algorithm first computes the unconstrained least-squares solution by
+ `numpy.linalg.lstsq` or `scipy.sparse.linalg.lsmr` depending on
+ `lsq_solver`. This solution is returned as optimal if it lies within the
+ bounds.
+
+ Method 'trf' runs the adaptation of the algorithm described in [STIR]_ for
+ a linear least-squares problem. The iterations are essentially the same as
+ in the nonlinear least-squares algorithm, but as the quadratic function
+ model is always accurate, we don't need to track or modify the radius of
+ a trust region. The line search (backtracking) is used as a safety net
+ when a selected step does not decrease the cost function. Read more
+ detailed description of the algorithm in `scipy.optimize.least_squares`.
+
+ Method 'bvls' runs a Python implementation of the algorithm described in
+ [BVLS]_. The algorithm maintains active and free sets of variables, on
+ each iteration chooses a new variable to move from the active set to the
+ free set and then solves the unconstrained least-squares problem on free
+ variables. This algorithm is guaranteed to give an accurate solution
+ eventually, but may require up to n iterations for a problem with n
+ variables. Additionally, an ad-hoc initialization procedure is
+ implemented, that determines which variables to set free or active
+ initially. It takes some number of iterations before actual BVLS starts,
+ but can significantly reduce the number of further iterations.
+
+ References
+ ----------
+ .. [STIR] M. A. Branch, T. F. Coleman, and Y. Li, "A Subspace, Interior,
+ and Conjugate Gradient Method for Large-Scale Bound-Constrained
+ Minimization Problems," SIAM Journal on Scientific Computing,
+ Vol. 21, Number 1, pp 1-23, 1999.
+ .. [BVLS] P. B. Start and R. L. Parker, "Bounded-Variable Least-Squares:
+ an Algorithm and Applications", Computational Statistics, 10,
+ 129-141, 1995.
+
+ Examples
+ --------
+ In this example, a problem with a large sparse matrix and bounds on the
+ variables is solved.
+
+ >>> import numpy as np
+ >>> from scipy.sparse import rand
+ >>> from scipy.optimize import lsq_linear
+ >>> rng = np.random.default_rng()
+ ...
+ >>> m = 20000
+ >>> n = 10000
+ ...
+ >>> A = rand(m, n, density=1e-4, random_state=rng)
+ >>> b = rng.standard_normal(m)
+ ...
+ >>> lb = rng.standard_normal(n)
+ >>> ub = lb + 1
+ ...
+ >>> res = lsq_linear(A, b, bounds=(lb, ub), lsmr_tol='auto', verbose=1)
+ # may vary
+ The relative change of the cost function is less than `tol`.
+ Number of iterations 16, initial cost 1.5039e+04, final cost 1.1112e+04,
+ first-order optimality 4.66e-08.
+ """
+ if method not in ['trf', 'bvls']:
+ raise ValueError("`method` must be 'trf' or 'bvls'")
+
+ if lsq_solver not in [None, 'exact', 'lsmr']:
+ raise ValueError("`solver` must be None, 'exact' or 'lsmr'.")
+
+ if verbose not in [0, 1, 2]:
+ raise ValueError("`verbose` must be in [0, 1, 2].")
+
+ if issparse(A):
+ A = csr_matrix(A)
+ elif not isinstance(A, LinearOperator):
+ A = np.atleast_2d(np.asarray(A))
+
+ if method == 'bvls':
+ if lsq_solver == 'lsmr':
+ raise ValueError("method='bvls' can't be used with "
+ "lsq_solver='lsmr'")
+
+ if not isinstance(A, np.ndarray):
+ raise ValueError("method='bvls' can't be used with `A` being "
+ "sparse or LinearOperator.")
+
+ if lsq_solver is None:
+ if isinstance(A, np.ndarray):
+ lsq_solver = 'exact'
+ else:
+ lsq_solver = 'lsmr'
+ elif lsq_solver == 'exact' and not isinstance(A, np.ndarray):
+ raise ValueError("`exact` solver can't be used when `A` is "
+ "sparse or LinearOperator.")
+
+ if len(A.shape) != 2: # No ndim for LinearOperator.
+ raise ValueError("`A` must have at most 2 dimensions.")
+
+ if max_iter is not None and max_iter <= 0:
+ raise ValueError("`max_iter` must be None or positive integer.")
+
+ m, n = A.shape
+
+ b = np.atleast_1d(b)
+ if b.ndim != 1:
+ raise ValueError("`b` must have at most 1 dimension.")
+
+ if b.size != m:
+ raise ValueError("Inconsistent shapes between `A` and `b`.")
+
+ if isinstance(bounds, Bounds):
+ lb = bounds.lb
+ ub = bounds.ub
+ else:
+ lb, ub = prepare_bounds(bounds, n)
+
+ if lb.shape != (n,) and ub.shape != (n,):
+ raise ValueError("Bounds have wrong shape.")
+
+ if np.any(lb >= ub):
+ raise ValueError("Each lower bound must be strictly less than each "
+ "upper bound.")
+
+ if lsmr_maxiter is not None and lsmr_maxiter < 1:
+ raise ValueError("`lsmr_maxiter` must be None or positive integer.")
+
+ if not ((isinstance(lsmr_tol, float) and lsmr_tol > 0) or
+ lsmr_tol in ('auto', None)):
+ raise ValueError("`lsmr_tol` must be None, 'auto', or positive float.")
+
+ if lsq_solver == 'exact':
+ unbd_lsq = np.linalg.lstsq(A, b, rcond=-1)
+ elif lsq_solver == 'lsmr':
+ first_lsmr_tol = lsmr_tol # tol of first call to lsmr
+ if lsmr_tol is None or lsmr_tol == 'auto':
+ first_lsmr_tol = 1e-2 * tol # default if lsmr_tol not defined
+ unbd_lsq = lsmr(A, b, maxiter=lsmr_maxiter,
+ atol=first_lsmr_tol, btol=first_lsmr_tol)
+ x_lsq = unbd_lsq[0] # extract the solution from the least squares solver
+
+ if in_bounds(x_lsq, lb, ub):
+ r = A @ x_lsq - b
+ cost = 0.5 * np.dot(r, r)
+ termination_status = 3
+ termination_message = TERMINATION_MESSAGES[termination_status]
+ g = compute_grad(A, r)
+ g_norm = norm(g, ord=np.inf)
+
+ if verbose > 0:
+ print(termination_message)
+ print(f"Final cost {cost:.4e}, first-order optimality {g_norm:.2e}")
+
+ return OptimizeResult(
+ x=x_lsq, fun=r, cost=cost, optimality=g_norm,
+ active_mask=np.zeros(n), unbounded_sol=unbd_lsq,
+ nit=0, status=termination_status,
+ message=termination_message, success=True)
+
+ if method == 'trf':
+ res = trf_linear(A, b, x_lsq, lb, ub, tol, lsq_solver, lsmr_tol,
+ max_iter, verbose, lsmr_maxiter=lsmr_maxiter)
+ elif method == 'bvls':
+ res = bvls(A, b, x_lsq, lb, ub, tol, max_iter, verbose)
+
+ res.unbounded_sol = unbd_lsq
+ res.message = TERMINATION_MESSAGES[res.status]
+ res.success = res.status > 0
+
+ if verbose > 0:
+ print(res.message)
+ print(
+ f"Number of iterations {res.nit}, initial cost {res.initial_cost:.4e}, "
+ f"final cost {res.cost:.4e}, first-order optimality {res.optimality:.2e}."
+ )
+
+ del res.initial_cost
+
+ return res
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/trf.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/trf.py
new file mode 100644
index 0000000000000000000000000000000000000000..9154bdba5b2cc41883811ba1820dfc251e515d6c
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/trf.py
@@ -0,0 +1,560 @@
+"""Trust Region Reflective algorithm for least-squares optimization.
+
+The algorithm is based on ideas from paper [STIR]_. The main idea is to
+account for the presence of the bounds by appropriate scaling of the variables (or,
+equivalently, changing a trust-region shape). Let's introduce a vector v:
+
+ | ub[i] - x[i], if g[i] < 0 and ub[i] < np.inf
+ v[i] = | x[i] - lb[i], if g[i] > 0 and lb[i] > -np.inf
+ | 1, otherwise
+
+where g is the gradient of a cost function and lb, ub are the bounds. Its
+components are distances to the bounds at which the anti-gradient points (if
+this distance is finite). Define a scaling matrix D = diag(v**0.5).
+First-order optimality conditions can be stated as
+
+ D^2 g(x) = 0.
+
+Meaning that components of the gradient should be zero for strictly interior
+variables, and components must point inside the feasible region for variables
+on the bound.
+
+Now consider this system of equations as a new optimization problem. If the
+point x is strictly interior (not on the bound), then the left-hand side is
+differentiable and the Newton step for it satisfies
+
+ (D^2 H + diag(g) Jv) p = -D^2 g
+
+where H is the Hessian matrix (or its J^T J approximation in least squares),
+Jv is the Jacobian matrix of v with components -1, 1 or 0, such that all
+elements of matrix C = diag(g) Jv are non-negative. Introduce the change
+of the variables x = D x_h (_h would be "hat" in LaTeX). In the new variables,
+we have a Newton step satisfying
+
+ B_h p_h = -g_h,
+
+where B_h = D H D + C, g_h = D g. In least squares B_h = J_h^T J_h, where
+J_h = J D. Note that J_h and g_h are proper Jacobian and gradient with respect
+to "hat" variables. To guarantee global convergence we formulate a
+trust-region problem based on the Newton step in the new variables:
+
+ 0.5 * p_h^T B_h p + g_h^T p_h -> min, ||p_h|| <= Delta
+
+In the original space B = H + D^{-1} C D^{-1}, and the equivalent trust-region
+problem is
+
+ 0.5 * p^T B p + g^T p -> min, ||D^{-1} p|| <= Delta
+
+Here, the meaning of the matrix D becomes more clear: it alters the shape
+of a trust-region, such that large steps towards the bounds are not allowed.
+In the implementation, the trust-region problem is solved in "hat" space,
+but handling of the bounds is done in the original space (see below and read
+the code).
+
+The introduction of the matrix D doesn't allow to ignore bounds, the algorithm
+must keep iterates strictly feasible (to satisfy aforementioned
+differentiability), the parameter theta controls step back from the boundary
+(see the code for details).
+
+The algorithm does another important trick. If the trust-region solution
+doesn't fit into the bounds, then a reflected (from a firstly encountered
+bound) search direction is considered. For motivation and analysis refer to
+[STIR]_ paper (and other papers of the authors). In practice, it doesn't need
+a lot of justifications, the algorithm simply chooses the best step among
+three: a constrained trust-region step, a reflected step and a constrained
+Cauchy step (a minimizer along -g_h in "hat" space, or -D^2 g in the original
+space).
+
+Another feature is that a trust-region radius control strategy is modified to
+account for appearance of the diagonal C matrix (called diag_h in the code).
+
+Note that all described peculiarities are completely gone as we consider
+problems without bounds (the algorithm becomes a standard trust-region type
+algorithm very similar to ones implemented in MINPACK).
+
+The implementation supports two methods of solving the trust-region problem.
+The first, called 'exact', applies SVD on Jacobian and then solves the problem
+very accurately using the algorithm described in [JJMore]_. It is not
+applicable to large problem. The second, called 'lsmr', uses the 2-D subspace
+approach (sometimes called "indefinite dogleg"), where the problem is solved
+in a subspace spanned by the gradient and the approximate Gauss-Newton step
+found by ``scipy.sparse.linalg.lsmr``. A 2-D trust-region problem is
+reformulated as a 4th order algebraic equation and solved very accurately by
+``numpy.roots``. The subspace approach allows to solve very large problems
+(up to couple of millions of residuals on a regular PC), provided the Jacobian
+matrix is sufficiently sparse.
+
+References
+----------
+.. [STIR] Branch, M.A., T.F. Coleman, and Y. Li, "A Subspace, Interior,
+ and Conjugate Gradient Method for Large-Scale Bound-Constrained
+ Minimization Problems," SIAM Journal on Scientific Computing,
+ Vol. 21, Number 1, pp 1-23, 1999.
+.. [JJMore] More, J. J., "The Levenberg-Marquardt Algorithm: Implementation
+ and Theory," Numerical Analysis, ed. G. A. Watson, Lecture
+"""
+import numpy as np
+from numpy.linalg import norm
+from scipy.linalg import svd, qr
+from scipy.sparse.linalg import lsmr
+from scipy.optimize import OptimizeResult
+
+from .common import (
+ step_size_to_bound, find_active_constraints, in_bounds,
+ make_strictly_feasible, intersect_trust_region, solve_lsq_trust_region,
+ solve_trust_region_2d, minimize_quadratic_1d, build_quadratic_1d,
+ evaluate_quadratic, right_multiplied_operator, regularized_lsq_operator,
+ CL_scaling_vector, compute_grad, compute_jac_scale, check_termination,
+ update_tr_radius, scale_for_robust_loss_function, print_header_nonlinear,
+ print_iteration_nonlinear)
+
+
+def trf(fun, jac, x0, f0, J0, lb, ub, ftol, xtol, gtol, max_nfev, x_scale,
+ loss_function, tr_solver, tr_options, verbose):
+ # For efficiency, it makes sense to run the simplified version of the
+ # algorithm when no bounds are imposed. We decided to write the two
+ # separate functions. It violates the DRY principle, but the individual
+ # functions are kept the most readable.
+ if np.all(lb == -np.inf) and np.all(ub == np.inf):
+ return trf_no_bounds(
+ fun, jac, x0, f0, J0, ftol, xtol, gtol, max_nfev, x_scale,
+ loss_function, tr_solver, tr_options, verbose)
+ else:
+ return trf_bounds(
+ fun, jac, x0, f0, J0, lb, ub, ftol, xtol, gtol, max_nfev, x_scale,
+ loss_function, tr_solver, tr_options, verbose)
+
+
+def select_step(x, J_h, diag_h, g_h, p, p_h, d, Delta, lb, ub, theta):
+ """Select the best step according to Trust Region Reflective algorithm."""
+ if in_bounds(x + p, lb, ub):
+ p_value = evaluate_quadratic(J_h, g_h, p_h, diag=diag_h)
+ return p, p_h, -p_value
+
+ p_stride, hits = step_size_to_bound(x, p, lb, ub)
+
+ # Compute the reflected direction.
+ r_h = np.copy(p_h)
+ r_h[hits.astype(bool)] *= -1
+ r = d * r_h
+
+ # Restrict trust-region step, such that it hits the bound.
+ p *= p_stride
+ p_h *= p_stride
+ x_on_bound = x + p
+
+ # Reflected direction will cross first either feasible region or trust
+ # region boundary.
+ _, to_tr = intersect_trust_region(p_h, r_h, Delta)
+ to_bound, _ = step_size_to_bound(x_on_bound, r, lb, ub)
+
+ # Find lower and upper bounds on a step size along the reflected
+ # direction, considering the strict feasibility requirement. There is no
+ # single correct way to do that, the chosen approach seems to work best
+ # on test problems.
+ r_stride = min(to_bound, to_tr)
+ if r_stride > 0:
+ r_stride_l = (1 - theta) * p_stride / r_stride
+ if r_stride == to_bound:
+ r_stride_u = theta * to_bound
+ else:
+ r_stride_u = to_tr
+ else:
+ r_stride_l = 0
+ r_stride_u = -1
+
+ # Check if reflection step is available.
+ if r_stride_l <= r_stride_u:
+ a, b, c = build_quadratic_1d(J_h, g_h, r_h, s0=p_h, diag=diag_h)
+ r_stride, r_value = minimize_quadratic_1d(
+ a, b, r_stride_l, r_stride_u, c=c)
+ r_h *= r_stride
+ r_h += p_h
+ r = r_h * d
+ else:
+ r_value = np.inf
+
+ # Now correct p_h to make it strictly interior.
+ p *= theta
+ p_h *= theta
+ p_value = evaluate_quadratic(J_h, g_h, p_h, diag=diag_h)
+
+ ag_h = -g_h
+ ag = d * ag_h
+
+ to_tr = Delta / norm(ag_h)
+ to_bound, _ = step_size_to_bound(x, ag, lb, ub)
+ if to_bound < to_tr:
+ ag_stride = theta * to_bound
+ else:
+ ag_stride = to_tr
+
+ a, b = build_quadratic_1d(J_h, g_h, ag_h, diag=diag_h)
+ ag_stride, ag_value = minimize_quadratic_1d(a, b, 0, ag_stride)
+ ag_h *= ag_stride
+ ag *= ag_stride
+
+ if p_value < r_value and p_value < ag_value:
+ return p, p_h, -p_value
+ elif r_value < p_value and r_value < ag_value:
+ return r, r_h, -r_value
+ else:
+ return ag, ag_h, -ag_value
+
+
+def trf_bounds(fun, jac, x0, f0, J0, lb, ub, ftol, xtol, gtol, max_nfev,
+ x_scale, loss_function, tr_solver, tr_options, verbose):
+ x = x0.copy()
+
+ f = f0
+ f_true = f.copy()
+ nfev = 1
+
+ J = J0
+ njev = 1
+ m, n = J.shape
+
+ if loss_function is not None:
+ rho = loss_function(f)
+ cost = 0.5 * np.sum(rho[0])
+ J, f = scale_for_robust_loss_function(J, f, rho)
+ else:
+ cost = 0.5 * np.dot(f, f)
+
+ g = compute_grad(J, f)
+
+ jac_scale = isinstance(x_scale, str) and x_scale == 'jac'
+ if jac_scale:
+ scale, scale_inv = compute_jac_scale(J)
+ else:
+ scale, scale_inv = x_scale, 1 / x_scale
+
+ v, dv = CL_scaling_vector(x, g, lb, ub)
+ v[dv != 0] *= scale_inv[dv != 0]
+ Delta = norm(x0 * scale_inv / v**0.5)
+ if Delta == 0:
+ Delta = 1.0
+
+ g_norm = norm(g * v, ord=np.inf)
+
+ f_augmented = np.zeros(m + n)
+ if tr_solver == 'exact':
+ J_augmented = np.empty((m + n, n))
+ elif tr_solver == 'lsmr':
+ reg_term = 0.0
+ regularize = tr_options.pop('regularize', True)
+
+ if max_nfev is None:
+ max_nfev = x0.size * 100
+
+ alpha = 0.0 # "Levenberg-Marquardt" parameter
+
+ termination_status = None
+ iteration = 0
+ step_norm = None
+ actual_reduction = None
+
+ if verbose == 2:
+ print_header_nonlinear()
+
+ while True:
+ v, dv = CL_scaling_vector(x, g, lb, ub)
+
+ g_norm = norm(g * v, ord=np.inf)
+ if g_norm < gtol:
+ termination_status = 1
+
+ if verbose == 2:
+ print_iteration_nonlinear(iteration, nfev, cost, actual_reduction,
+ step_norm, g_norm)
+
+ if termination_status is not None or nfev == max_nfev:
+ break
+
+ # Now compute variables in "hat" space. Here, we also account for
+ # scaling introduced by `x_scale` parameter. This part is a bit tricky,
+ # you have to write down the formulas and see how the trust-region
+ # problem is formulated when the two types of scaling are applied.
+ # The idea is that first we apply `x_scale` and then apply Coleman-Li
+ # approach in the new variables.
+
+ # v is recomputed in the variables after applying `x_scale`, note that
+ # components which were identically 1 not affected.
+ v[dv != 0] *= scale_inv[dv != 0]
+
+ # Here, we apply two types of scaling.
+ d = v**0.5 * scale
+
+ # C = diag(g * scale) Jv
+ diag_h = g * dv * scale
+
+ # After all this has been done, we continue normally.
+
+ # "hat" gradient.
+ g_h = d * g
+
+ f_augmented[:m] = f
+ if tr_solver == 'exact':
+ J_augmented[:m] = J * d
+ J_h = J_augmented[:m] # Memory view.
+ J_augmented[m:] = np.diag(diag_h**0.5)
+ U, s, V = svd(J_augmented, full_matrices=False)
+ V = V.T
+ uf = U.T.dot(f_augmented)
+ elif tr_solver == 'lsmr':
+ J_h = right_multiplied_operator(J, d)
+
+ if regularize:
+ a, b = build_quadratic_1d(J_h, g_h, -g_h, diag=diag_h)
+ to_tr = Delta / norm(g_h)
+ ag_value = minimize_quadratic_1d(a, b, 0, to_tr)[1]
+ reg_term = -ag_value / Delta**2
+
+ lsmr_op = regularized_lsq_operator(J_h, (diag_h + reg_term)**0.5)
+ gn_h = lsmr(lsmr_op, f_augmented, **tr_options)[0]
+ S = np.vstack((g_h, gn_h)).T
+ S, _ = qr(S, mode='economic')
+ JS = J_h.dot(S) # LinearOperator does dot too.
+ B_S = np.dot(JS.T, JS) + np.dot(S.T * diag_h, S)
+ g_S = S.T.dot(g_h)
+
+ # theta controls step back step ratio from the bounds.
+ theta = max(0.995, 1 - g_norm)
+
+ actual_reduction = -1
+ while actual_reduction <= 0 and nfev < max_nfev:
+ if tr_solver == 'exact':
+ p_h, alpha, n_iter = solve_lsq_trust_region(
+ n, m, uf, s, V, Delta, initial_alpha=alpha)
+ elif tr_solver == 'lsmr':
+ p_S, _ = solve_trust_region_2d(B_S, g_S, Delta)
+ p_h = S.dot(p_S)
+
+ p = d * p_h # Trust-region solution in the original space.
+ step, step_h, predicted_reduction = select_step(
+ x, J_h, diag_h, g_h, p, p_h, d, Delta, lb, ub, theta)
+
+ x_new = make_strictly_feasible(x + step, lb, ub, rstep=0)
+ f_new = fun(x_new)
+ nfev += 1
+
+ step_h_norm = norm(step_h)
+
+ if not np.all(np.isfinite(f_new)):
+ Delta = 0.25 * step_h_norm
+ continue
+
+ # Usual trust-region step quality estimation.
+ if loss_function is not None:
+ cost_new = loss_function(f_new, cost_only=True)
+ else:
+ cost_new = 0.5 * np.dot(f_new, f_new)
+ actual_reduction = cost - cost_new
+ Delta_new, ratio = update_tr_radius(
+ Delta, actual_reduction, predicted_reduction,
+ step_h_norm, step_h_norm > 0.95 * Delta)
+
+ step_norm = norm(step)
+ termination_status = check_termination(
+ actual_reduction, cost, step_norm, norm(x), ratio, ftol, xtol)
+ if termination_status is not None:
+ break
+
+ alpha *= Delta / Delta_new
+ Delta = Delta_new
+
+ if actual_reduction > 0:
+ x = x_new
+
+ f = f_new
+ f_true = f.copy()
+
+ cost = cost_new
+
+ J = jac(x, f)
+ njev += 1
+
+ if loss_function is not None:
+ rho = loss_function(f)
+ J, f = scale_for_robust_loss_function(J, f, rho)
+
+ g = compute_grad(J, f)
+
+ if jac_scale:
+ scale, scale_inv = compute_jac_scale(J, scale_inv)
+ else:
+ step_norm = 0
+ actual_reduction = 0
+
+ iteration += 1
+
+ if termination_status is None:
+ termination_status = 0
+
+ active_mask = find_active_constraints(x, lb, ub, rtol=xtol)
+ return OptimizeResult(
+ x=x, cost=cost, fun=f_true, jac=J, grad=g, optimality=g_norm,
+ active_mask=active_mask, nfev=nfev, njev=njev,
+ status=termination_status)
+
+
+def trf_no_bounds(fun, jac, x0, f0, J0, ftol, xtol, gtol, max_nfev,
+ x_scale, loss_function, tr_solver, tr_options, verbose):
+ x = x0.copy()
+
+ f = f0
+ f_true = f.copy()
+ nfev = 1
+
+ J = J0
+ njev = 1
+ m, n = J.shape
+
+ if loss_function is not None:
+ rho = loss_function(f)
+ cost = 0.5 * np.sum(rho[0])
+ J, f = scale_for_robust_loss_function(J, f, rho)
+ else:
+ cost = 0.5 * np.dot(f, f)
+
+ g = compute_grad(J, f)
+
+ jac_scale = isinstance(x_scale, str) and x_scale == 'jac'
+ if jac_scale:
+ scale, scale_inv = compute_jac_scale(J)
+ else:
+ scale, scale_inv = x_scale, 1 / x_scale
+
+ Delta = norm(x0 * scale_inv)
+ if Delta == 0:
+ Delta = 1.0
+
+ if tr_solver == 'lsmr':
+ reg_term = 0
+ damp = tr_options.pop('damp', 0.0)
+ regularize = tr_options.pop('regularize', True)
+
+ if max_nfev is None:
+ max_nfev = x0.size * 100
+
+ alpha = 0.0 # "Levenberg-Marquardt" parameter
+
+ termination_status = None
+ iteration = 0
+ step_norm = None
+ actual_reduction = None
+
+ if verbose == 2:
+ print_header_nonlinear()
+
+ while True:
+ g_norm = norm(g, ord=np.inf)
+ if g_norm < gtol:
+ termination_status = 1
+
+ if verbose == 2:
+ print_iteration_nonlinear(iteration, nfev, cost, actual_reduction,
+ step_norm, g_norm)
+
+ if termination_status is not None or nfev == max_nfev:
+ break
+
+ d = scale
+ g_h = d * g
+
+ if tr_solver == 'exact':
+ J_h = J * d
+ U, s, V = svd(J_h, full_matrices=False)
+ V = V.T
+ uf = U.T.dot(f)
+ elif tr_solver == 'lsmr':
+ J_h = right_multiplied_operator(J, d)
+
+ if regularize:
+ a, b = build_quadratic_1d(J_h, g_h, -g_h)
+ to_tr = Delta / norm(g_h)
+ ag_value = minimize_quadratic_1d(a, b, 0, to_tr)[1]
+ reg_term = -ag_value / Delta**2
+
+ damp_full = (damp**2 + reg_term)**0.5
+ gn_h = lsmr(J_h, f, damp=damp_full, **tr_options)[0]
+ S = np.vstack((g_h, gn_h)).T
+ S, _ = qr(S, mode='economic')
+ JS = J_h.dot(S)
+ B_S = np.dot(JS.T, JS)
+ g_S = S.T.dot(g_h)
+
+ actual_reduction = -1
+ while actual_reduction <= 0 and nfev < max_nfev:
+ if tr_solver == 'exact':
+ step_h, alpha, n_iter = solve_lsq_trust_region(
+ n, m, uf, s, V, Delta, initial_alpha=alpha)
+ elif tr_solver == 'lsmr':
+ p_S, _ = solve_trust_region_2d(B_S, g_S, Delta)
+ step_h = S.dot(p_S)
+
+ predicted_reduction = -evaluate_quadratic(J_h, g_h, step_h)
+ step = d * step_h
+ x_new = x + step
+ f_new = fun(x_new)
+ nfev += 1
+
+ step_h_norm = norm(step_h)
+
+ if not np.all(np.isfinite(f_new)):
+ Delta = 0.25 * step_h_norm
+ continue
+
+ # Usual trust-region step quality estimation.
+ if loss_function is not None:
+ cost_new = loss_function(f_new, cost_only=True)
+ else:
+ cost_new = 0.5 * np.dot(f_new, f_new)
+ actual_reduction = cost - cost_new
+
+ Delta_new, ratio = update_tr_radius(
+ Delta, actual_reduction, predicted_reduction,
+ step_h_norm, step_h_norm > 0.95 * Delta)
+
+ step_norm = norm(step)
+ termination_status = check_termination(
+ actual_reduction, cost, step_norm, norm(x), ratio, ftol, xtol)
+ if termination_status is not None:
+ break
+
+ alpha *= Delta / Delta_new
+ Delta = Delta_new
+
+ if actual_reduction > 0:
+ x = x_new
+
+ f = f_new
+ f_true = f.copy()
+
+ cost = cost_new
+
+ J = jac(x, f)
+ njev += 1
+
+ if loss_function is not None:
+ rho = loss_function(f)
+ J, f = scale_for_robust_loss_function(J, f, rho)
+
+ g = compute_grad(J, f)
+
+ if jac_scale:
+ scale, scale_inv = compute_jac_scale(J, scale_inv)
+ else:
+ step_norm = 0
+ actual_reduction = 0
+
+ iteration += 1
+
+ if termination_status is None:
+ termination_status = 0
+
+ active_mask = np.zeros_like(x)
+ return OptimizeResult(
+ x=x, cost=cost, fun=f_true, jac=J, grad=g, optimality=g_norm,
+ active_mask=active_mask, nfev=nfev, njev=njev,
+ status=termination_status)
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/trf_linear.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/trf_linear.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd752763179bcf97945c7f34ce6a9e49e85c819e
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_lsq/trf_linear.py
@@ -0,0 +1,249 @@
+"""The adaptation of Trust Region Reflective algorithm for a linear
+least-squares problem."""
+import numpy as np
+from numpy.linalg import norm
+from scipy.linalg import qr, solve_triangular
+from scipy.sparse.linalg import lsmr
+from scipy.optimize import OptimizeResult
+
+from .givens_elimination import givens_elimination
+from .common import (
+ EPS, step_size_to_bound, find_active_constraints, in_bounds,
+ make_strictly_feasible, build_quadratic_1d, evaluate_quadratic,
+ minimize_quadratic_1d, CL_scaling_vector, reflective_transformation,
+ print_header_linear, print_iteration_linear, compute_grad,
+ regularized_lsq_operator, right_multiplied_operator)
+
+
+def regularized_lsq_with_qr(m, n, R, QTb, perm, diag, copy_R=True):
+ """Solve regularized least squares using information from QR-decomposition.
+
+ The initial problem is to solve the following system in a least-squares
+ sense::
+
+ A x = b
+ D x = 0
+
+ where D is diagonal matrix. The method is based on QR decomposition
+ of the form A P = Q R, where P is a column permutation matrix, Q is an
+ orthogonal matrix and R is an upper triangular matrix.
+
+ Parameters
+ ----------
+ m, n : int
+ Initial shape of A.
+ R : ndarray, shape (n, n)
+ Upper triangular matrix from QR decomposition of A.
+ QTb : ndarray, shape (n,)
+ First n components of Q^T b.
+ perm : ndarray, shape (n,)
+ Array defining column permutation of A, such that ith column of
+ P is perm[i]-th column of identity matrix.
+ diag : ndarray, shape (n,)
+ Array containing diagonal elements of D.
+
+ Returns
+ -------
+ x : ndarray, shape (n,)
+ Found least-squares solution.
+ """
+ if copy_R:
+ R = R.copy()
+ v = QTb.copy()
+
+ givens_elimination(R, v, diag[perm])
+
+ abs_diag_R = np.abs(np.diag(R))
+ threshold = EPS * max(m, n) * np.max(abs_diag_R)
+ nns, = np.nonzero(abs_diag_R > threshold)
+
+ R = R[np.ix_(nns, nns)]
+ v = v[nns]
+
+ x = np.zeros(n)
+ x[perm[nns]] = solve_triangular(R, v)
+
+ return x
+
+
+def backtracking(A, g, x, p, theta, p_dot_g, lb, ub):
+ """Find an appropriate step size using backtracking line search."""
+ alpha = 1
+ while True:
+ x_new, _ = reflective_transformation(x + alpha * p, lb, ub)
+ step = x_new - x
+ cost_change = -evaluate_quadratic(A, g, step)
+ if cost_change > -0.1 * alpha * p_dot_g:
+ break
+ alpha *= 0.5
+
+ active = find_active_constraints(x_new, lb, ub)
+ if np.any(active != 0):
+ x_new, _ = reflective_transformation(x + theta * alpha * p, lb, ub)
+ x_new = make_strictly_feasible(x_new, lb, ub, rstep=0)
+ step = x_new - x
+ cost_change = -evaluate_quadratic(A, g, step)
+
+ return x, step, cost_change
+
+
+def select_step(x, A_h, g_h, c_h, p, p_h, d, lb, ub, theta):
+ """Select the best step according to Trust Region Reflective algorithm."""
+ if in_bounds(x + p, lb, ub):
+ return p
+
+ p_stride, hits = step_size_to_bound(x, p, lb, ub)
+ r_h = np.copy(p_h)
+ r_h[hits.astype(bool)] *= -1
+ r = d * r_h
+
+ # Restrict step, such that it hits the bound.
+ p *= p_stride
+ p_h *= p_stride
+ x_on_bound = x + p
+
+ # Find the step size along reflected direction.
+ r_stride_u, _ = step_size_to_bound(x_on_bound, r, lb, ub)
+
+ # Stay interior.
+ r_stride_l = (1 - theta) * r_stride_u
+ r_stride_u *= theta
+
+ if r_stride_u > 0:
+ a, b, c = build_quadratic_1d(A_h, g_h, r_h, s0=p_h, diag=c_h)
+ r_stride, r_value = minimize_quadratic_1d(
+ a, b, r_stride_l, r_stride_u, c=c)
+ r_h = p_h + r_h * r_stride
+ r = d * r_h
+ else:
+ r_value = np.inf
+
+ # Now correct p_h to make it strictly interior.
+ p_h *= theta
+ p *= theta
+ p_value = evaluate_quadratic(A_h, g_h, p_h, diag=c_h)
+
+ ag_h = -g_h
+ ag = d * ag_h
+ ag_stride_u, _ = step_size_to_bound(x, ag, lb, ub)
+ ag_stride_u *= theta
+ a, b = build_quadratic_1d(A_h, g_h, ag_h, diag=c_h)
+ ag_stride, ag_value = minimize_quadratic_1d(a, b, 0, ag_stride_u)
+ ag *= ag_stride
+
+ if p_value < r_value and p_value < ag_value:
+ return p
+ elif r_value < p_value and r_value < ag_value:
+ return r
+ else:
+ return ag
+
+
+def trf_linear(A, b, x_lsq, lb, ub, tol, lsq_solver, lsmr_tol,
+ max_iter, verbose, *, lsmr_maxiter=None):
+ m, n = A.shape
+ x, _ = reflective_transformation(x_lsq, lb, ub)
+ x = make_strictly_feasible(x, lb, ub, rstep=0.1)
+
+ if lsq_solver == 'exact':
+ QT, R, perm = qr(A, mode='economic', pivoting=True)
+ QT = QT.T
+
+ if m < n:
+ R = np.vstack((R, np.zeros((n - m, n))))
+
+ QTr = np.zeros(n)
+ k = min(m, n)
+ elif lsq_solver == 'lsmr':
+ r_aug = np.zeros(m + n)
+ auto_lsmr_tol = False
+ if lsmr_tol is None:
+ lsmr_tol = 1e-2 * tol
+ elif lsmr_tol == 'auto':
+ auto_lsmr_tol = True
+
+ r = A.dot(x) - b
+ g = compute_grad(A, r)
+ cost = 0.5 * np.dot(r, r)
+ initial_cost = cost
+
+ termination_status = None
+ step_norm = None
+ cost_change = None
+
+ if max_iter is None:
+ max_iter = 100
+
+ if verbose == 2:
+ print_header_linear()
+
+ for iteration in range(max_iter):
+ v, dv = CL_scaling_vector(x, g, lb, ub)
+ g_scaled = g * v
+ g_norm = norm(g_scaled, ord=np.inf)
+ if g_norm < tol:
+ termination_status = 1
+
+ if verbose == 2:
+ print_iteration_linear(iteration, cost, cost_change,
+ step_norm, g_norm)
+
+ if termination_status is not None:
+ break
+
+ diag_h = g * dv
+ diag_root_h = diag_h ** 0.5
+ d = v ** 0.5
+ g_h = d * g
+
+ A_h = right_multiplied_operator(A, d)
+ if lsq_solver == 'exact':
+ QTr[:k] = QT.dot(r)
+ p_h = -regularized_lsq_with_qr(m, n, R * d[perm], QTr, perm,
+ diag_root_h, copy_R=False)
+ elif lsq_solver == 'lsmr':
+ lsmr_op = regularized_lsq_operator(A_h, diag_root_h)
+ r_aug[:m] = r
+ if auto_lsmr_tol:
+ eta = 1e-2 * min(0.5, g_norm)
+ lsmr_tol = max(EPS, min(0.1, eta * g_norm))
+ p_h = -lsmr(lsmr_op, r_aug, maxiter=lsmr_maxiter,
+ atol=lsmr_tol, btol=lsmr_tol)[0]
+
+ p = d * p_h
+
+ p_dot_g = np.dot(p, g)
+ if p_dot_g > 0:
+ termination_status = -1
+
+ theta = 1 - min(0.005, g_norm)
+ step = select_step(x, A_h, g_h, diag_h, p, p_h, d, lb, ub, theta)
+ cost_change = -evaluate_quadratic(A, g, step)
+
+ # Perhaps almost never executed, the idea is that `p` is descent
+ # direction thus we must find acceptable cost decrease using simple
+ # "backtracking", otherwise the algorithm's logic would break.
+ if cost_change < 0:
+ x, step, cost_change = backtracking(
+ A, g, x, p, theta, p_dot_g, lb, ub)
+ else:
+ x = make_strictly_feasible(x + step, lb, ub, rstep=0)
+
+ step_norm = norm(step)
+ r = A.dot(x) - b
+ g = compute_grad(A, r)
+
+ if cost_change < tol * cost:
+ termination_status = 2
+
+ cost = 0.5 * np.dot(r, r)
+
+ if termination_status is None:
+ termination_status = 0
+
+ active_mask = find_active_constraints(x, lb, ub, rtol=tol)
+
+ return OptimizeResult(
+ x=x, fun=r, cost=cost, optimality=g_norm, active_mask=active_mask,
+ nit=iteration + 1, status=termination_status,
+ initial_cost=initial_cost)
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/__pycache__/__init__.cpython-310.pyc b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2e0fac506dd0fffd0d95b80957f7e91a3ed739f4
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/__pycache__/__init__.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/__pycache__/canonical_constraint.cpython-310.pyc b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/__pycache__/canonical_constraint.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..180ec8ee20cc65aa3d73170883f2b4b38dd9928b
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/__pycache__/canonical_constraint.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/__pycache__/projections.cpython-310.pyc b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/__pycache__/projections.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b1fbcc1d3533466eee9c989f0774b7f1ff0a86ab
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/__pycache__/projections.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/equality_constrained_sqp.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/equality_constrained_sqp.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb4c05dcdd03fb990d3418220a398e249ef581ee
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/equality_constrained_sqp.py
@@ -0,0 +1,231 @@
+"""Byrd-Omojokun Trust-Region SQP method."""
+
+from scipy.sparse import eye as speye
+from .projections import projections
+from .qp_subproblem import modified_dogleg, projected_cg, box_intersections
+import numpy as np
+from numpy.linalg import norm
+
+__all__ = ['equality_constrained_sqp']
+
+
+def default_scaling(x):
+ n, = np.shape(x)
+ return speye(n)
+
+
+def equality_constrained_sqp(fun_and_constr, grad_and_jac, lagr_hess,
+ x0, fun0, grad0, constr0,
+ jac0, stop_criteria,
+ state,
+ initial_penalty,
+ initial_trust_radius,
+ factorization_method,
+ trust_lb=None,
+ trust_ub=None,
+ scaling=default_scaling):
+ """Solve nonlinear equality-constrained problem using trust-region SQP.
+
+ Solve optimization problem:
+
+ minimize fun(x)
+ subject to: constr(x) = 0
+
+ using Byrd-Omojokun Trust-Region SQP method described in [1]_. Several
+ implementation details are based on [2]_ and [3]_, p. 549.
+
+ References
+ ----------
+ .. [1] Lalee, Marucha, Jorge Nocedal, and Todd Plantenga. "On the
+ implementation of an algorithm for large-scale equality
+ constrained optimization." SIAM Journal on
+ Optimization 8.3 (1998): 682-706.
+ .. [2] Byrd, Richard H., Mary E. Hribar, and Jorge Nocedal.
+ "An interior point algorithm for large-scale nonlinear
+ programming." SIAM Journal on Optimization 9.4 (1999): 877-900.
+ .. [3] Nocedal, Jorge, and Stephen J. Wright. "Numerical optimization"
+ Second Edition (2006).
+ """
+ PENALTY_FACTOR = 0.3 # Rho from formula (3.51), reference [2]_, p.891.
+ LARGE_REDUCTION_RATIO = 0.9
+ INTERMEDIARY_REDUCTION_RATIO = 0.3
+ SUFFICIENT_REDUCTION_RATIO = 1e-8 # Eta from reference [2]_, p.892.
+ TRUST_ENLARGEMENT_FACTOR_L = 7.0
+ TRUST_ENLARGEMENT_FACTOR_S = 2.0
+ MAX_TRUST_REDUCTION = 0.5
+ MIN_TRUST_REDUCTION = 0.1
+ SOC_THRESHOLD = 0.1
+ TR_FACTOR = 0.8 # Zeta from formula (3.21), reference [2]_, p.885.
+ BOX_FACTOR = 0.5
+
+ n, = np.shape(x0) # Number of parameters
+
+ # Set default lower and upper bounds.
+ if trust_lb is None:
+ trust_lb = np.full(n, -np.inf)
+ if trust_ub is None:
+ trust_ub = np.full(n, np.inf)
+
+ # Initial values
+ x = np.copy(x0)
+ trust_radius = initial_trust_radius
+ penalty = initial_penalty
+ # Compute Values
+ f = fun0
+ c = grad0
+ b = constr0
+ A = jac0
+ S = scaling(x)
+ # Get projections
+ try:
+ Z, LS, Y = projections(A, factorization_method)
+ except ValueError as e:
+ if str(e) == "expected square matrix":
+ # can be the case if there are more equality
+ # constraints than independent variables
+ raise ValueError(
+ "The 'expected square matrix' error can occur if there are"
+ " more equality constraints than independent variables."
+ " Consider how your constraints are set up, or use"
+ " factorization_method='SVDFactorization'."
+ ) from e
+ else:
+ raise e
+
+ # Compute least-square lagrange multipliers
+ v = -LS.dot(c)
+ # Compute Hessian
+ H = lagr_hess(x, v)
+
+ # Update state parameters
+ optimality = norm(c + A.T.dot(v), np.inf)
+ constr_violation = norm(b, np.inf) if len(b) > 0 else 0
+ cg_info = {'niter': 0, 'stop_cond': 0,
+ 'hits_boundary': False}
+
+ last_iteration_failed = False
+ while not stop_criteria(state, x, last_iteration_failed,
+ optimality, constr_violation,
+ trust_radius, penalty, cg_info):
+ # Normal Step - `dn`
+ # minimize 1/2*||A dn + b||^2
+ # subject to:
+ # ||dn|| <= TR_FACTOR * trust_radius
+ # BOX_FACTOR * lb <= dn <= BOX_FACTOR * ub.
+ dn = modified_dogleg(A, Y, b,
+ TR_FACTOR*trust_radius,
+ BOX_FACTOR*trust_lb,
+ BOX_FACTOR*trust_ub)
+
+ # Tangential Step - `dt`
+ # Solve the QP problem:
+ # minimize 1/2 dt.T H dt + dt.T (H dn + c)
+ # subject to:
+ # A dt = 0
+ # ||dt|| <= sqrt(trust_radius**2 - ||dn||**2)
+ # lb - dn <= dt <= ub - dn
+ c_t = H.dot(dn) + c
+ b_t = np.zeros_like(b)
+ trust_radius_t = np.sqrt(trust_radius**2 - np.linalg.norm(dn)**2)
+ lb_t = trust_lb - dn
+ ub_t = trust_ub - dn
+ dt, cg_info = projected_cg(H, c_t, Z, Y, b_t,
+ trust_radius_t,
+ lb_t, ub_t)
+
+ # Compute update (normal + tangential steps).
+ d = dn + dt
+
+ # Compute second order model: 1/2 d H d + c.T d + f.
+ quadratic_model = 1/2*(H.dot(d)).dot(d) + c.T.dot(d)
+ # Compute linearized constraint: l = A d + b.
+ linearized_constr = A.dot(d)+b
+ # Compute new penalty parameter according to formula (3.52),
+ # reference [2]_, p.891.
+ vpred = norm(b) - norm(linearized_constr)
+ # Guarantee `vpred` always positive,
+ # regardless of roundoff errors.
+ vpred = max(1e-16, vpred)
+ previous_penalty = penalty
+ if quadratic_model > 0:
+ new_penalty = quadratic_model / ((1-PENALTY_FACTOR)*vpred)
+ penalty = max(penalty, new_penalty)
+ # Compute predicted reduction according to formula (3.52),
+ # reference [2]_, p.891.
+ predicted_reduction = -quadratic_model + penalty*vpred
+
+ # Compute merit function at current point
+ merit_function = f + penalty*norm(b)
+ # Evaluate function and constraints at trial point
+ x_next = x + S.dot(d)
+ f_next, b_next = fun_and_constr(x_next)
+ # Compute merit function at trial point
+ merit_function_next = f_next + penalty*norm(b_next)
+ # Compute actual reduction according to formula (3.54),
+ # reference [2]_, p.892.
+ actual_reduction = merit_function - merit_function_next
+ # Compute reduction ratio
+ reduction_ratio = actual_reduction / predicted_reduction
+
+ # Second order correction (SOC), reference [2]_, p.892.
+ if reduction_ratio < SUFFICIENT_REDUCTION_RATIO and \
+ norm(dn) <= SOC_THRESHOLD * norm(dt):
+ # Compute second order correction
+ y = -Y.dot(b_next)
+ # Make sure increment is inside box constraints
+ _, t, intersect = box_intersections(d, y, trust_lb, trust_ub)
+ # Compute tentative point
+ x_soc = x + S.dot(d + t*y)
+ f_soc, b_soc = fun_and_constr(x_soc)
+ # Recompute actual reduction
+ merit_function_soc = f_soc + penalty*norm(b_soc)
+ actual_reduction_soc = merit_function - merit_function_soc
+ # Recompute reduction ratio
+ reduction_ratio_soc = actual_reduction_soc / predicted_reduction
+ if intersect and reduction_ratio_soc >= SUFFICIENT_REDUCTION_RATIO:
+ x_next = x_soc
+ f_next = f_soc
+ b_next = b_soc
+ reduction_ratio = reduction_ratio_soc
+
+ # Readjust trust region step, formula (3.55), reference [2]_, p.892.
+ if reduction_ratio >= LARGE_REDUCTION_RATIO:
+ trust_radius = max(TRUST_ENLARGEMENT_FACTOR_L * norm(d),
+ trust_radius)
+ elif reduction_ratio >= INTERMEDIARY_REDUCTION_RATIO:
+ trust_radius = max(TRUST_ENLARGEMENT_FACTOR_S * norm(d),
+ trust_radius)
+ # Reduce trust region step, according to reference [3]_, p.696.
+ elif reduction_ratio < SUFFICIENT_REDUCTION_RATIO:
+ trust_reduction = ((1-SUFFICIENT_REDUCTION_RATIO) /
+ (1-reduction_ratio))
+ new_trust_radius = trust_reduction * norm(d)
+ if new_trust_radius >= MAX_TRUST_REDUCTION * trust_radius:
+ trust_radius *= MAX_TRUST_REDUCTION
+ elif new_trust_radius >= MIN_TRUST_REDUCTION * trust_radius:
+ trust_radius = new_trust_radius
+ else:
+ trust_radius *= MIN_TRUST_REDUCTION
+
+ # Update iteration
+ if reduction_ratio >= SUFFICIENT_REDUCTION_RATIO:
+ x = x_next
+ f, b = f_next, b_next
+ c, A = grad_and_jac(x)
+ S = scaling(x)
+ # Get projections
+ Z, LS, Y = projections(A, factorization_method)
+ # Compute least-square lagrange multipliers
+ v = -LS.dot(c)
+ # Compute Hessian
+ H = lagr_hess(x, v)
+ # Set Flag
+ last_iteration_failed = False
+ # Otimality values
+ optimality = norm(c + A.T.dot(v), np.inf)
+ constr_violation = norm(b, np.inf) if len(b) > 0 else 0
+ else:
+ penalty = previous_penalty
+ last_iteration_failed = True
+
+ return x, state
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/minimize_trustregion_constr.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/minimize_trustregion_constr.py
new file mode 100644
index 0000000000000000000000000000000000000000..2835ea5445c0eafc303f0cb1ab8543f48b7e3bb9
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/minimize_trustregion_constr.py
@@ -0,0 +1,564 @@
+import time
+import numpy as np
+from scipy.sparse.linalg import LinearOperator
+from .._differentiable_functions import VectorFunction
+from .._constraints import (
+ NonlinearConstraint, LinearConstraint, PreparedConstraint, Bounds, strict_bounds)
+from .._hessian_update_strategy import BFGS
+from .._optimize import OptimizeResult
+from .._differentiable_functions import ScalarFunction
+from .equality_constrained_sqp import equality_constrained_sqp
+from .canonical_constraint import (CanonicalConstraint,
+ initial_constraints_as_canonical)
+from .tr_interior_point import tr_interior_point
+from .report import BasicReport, SQPReport, IPReport
+
+
+TERMINATION_MESSAGES = {
+ 0: "The maximum number of function evaluations is exceeded.",
+ 1: "`gtol` termination condition is satisfied.",
+ 2: "`xtol` termination condition is satisfied.",
+ 3: "`callback` function requested termination."
+}
+
+
+class HessianLinearOperator:
+ """Build LinearOperator from hessp"""
+ def __init__(self, hessp, n):
+ self.hessp = hessp
+ self.n = n
+
+ def __call__(self, x, *args):
+ def matvec(p):
+ return self.hessp(x, p, *args)
+
+ return LinearOperator((self.n, self.n), matvec=matvec)
+
+
+class LagrangianHessian:
+ """The Hessian of the Lagrangian as LinearOperator.
+
+ The Lagrangian is computed as the objective function plus all the
+ constraints multiplied with some numbers (Lagrange multipliers).
+ """
+ def __init__(self, n, objective_hess, constraints_hess):
+ self.n = n
+ self.objective_hess = objective_hess
+ self.constraints_hess = constraints_hess
+
+ def __call__(self, x, v_eq=np.empty(0), v_ineq=np.empty(0)):
+ H_objective = self.objective_hess(x)
+ H_constraints = self.constraints_hess(x, v_eq, v_ineq)
+
+ def matvec(p):
+ return H_objective.dot(p) + H_constraints.dot(p)
+
+ return LinearOperator((self.n, self.n), matvec)
+
+
+def update_state_sqp(state, x, last_iteration_failed, objective, prepared_constraints,
+ start_time, tr_radius, constr_penalty, cg_info):
+ state.nit += 1
+ state.nfev = objective.nfev
+ state.njev = objective.ngev
+ state.nhev = objective.nhev
+ state.constr_nfev = [c.fun.nfev if isinstance(c.fun, VectorFunction) else 0
+ for c in prepared_constraints]
+ state.constr_njev = [c.fun.njev if isinstance(c.fun, VectorFunction) else 0
+ for c in prepared_constraints]
+ state.constr_nhev = [c.fun.nhev if isinstance(c.fun, VectorFunction) else 0
+ for c in prepared_constraints]
+
+ if not last_iteration_failed:
+ state.x = x
+ state.fun = objective.f
+ state.grad = objective.g
+ state.v = [c.fun.v for c in prepared_constraints]
+ state.constr = [c.fun.f for c in prepared_constraints]
+ state.jac = [c.fun.J for c in prepared_constraints]
+ # Compute Lagrangian Gradient
+ state.lagrangian_grad = np.copy(state.grad)
+ for c in prepared_constraints:
+ state.lagrangian_grad += c.fun.J.T.dot(c.fun.v)
+ state.optimality = np.linalg.norm(state.lagrangian_grad, np.inf)
+ # Compute maximum constraint violation
+ state.constr_violation = 0
+ for i in range(len(prepared_constraints)):
+ lb, ub = prepared_constraints[i].bounds
+ c = state.constr[i]
+ state.constr_violation = np.max([state.constr_violation,
+ np.max(lb - c),
+ np.max(c - ub)])
+
+ state.execution_time = time.time() - start_time
+ state.tr_radius = tr_radius
+ state.constr_penalty = constr_penalty
+ state.cg_niter += cg_info["niter"]
+ state.cg_stop_cond = cg_info["stop_cond"]
+
+ return state
+
+
+def update_state_ip(state, x, last_iteration_failed, objective,
+ prepared_constraints, start_time,
+ tr_radius, constr_penalty, cg_info,
+ barrier_parameter, barrier_tolerance):
+ state = update_state_sqp(state, x, last_iteration_failed, objective,
+ prepared_constraints, start_time, tr_radius,
+ constr_penalty, cg_info)
+ state.barrier_parameter = barrier_parameter
+ state.barrier_tolerance = barrier_tolerance
+ return state
+
+
+def _minimize_trustregion_constr(fun, x0, args, grad,
+ hess, hessp, bounds, constraints,
+ xtol=1e-8, gtol=1e-8,
+ barrier_tol=1e-8,
+ sparse_jacobian=None,
+ callback=None, maxiter=1000,
+ verbose=0, finite_diff_rel_step=None,
+ initial_constr_penalty=1.0, initial_tr_radius=1.0,
+ initial_barrier_parameter=0.1,
+ initial_barrier_tolerance=0.1,
+ factorization_method=None,
+ disp=False):
+ """Minimize a scalar function subject to constraints.
+
+ Parameters
+ ----------
+ gtol : float, optional
+ Tolerance for termination by the norm of the Lagrangian gradient.
+ The algorithm will terminate when both the infinity norm (i.e., max
+ abs value) of the Lagrangian gradient and the constraint violation
+ are smaller than ``gtol``. Default is 1e-8.
+ xtol : float, optional
+ Tolerance for termination by the change of the independent variable.
+ The algorithm will terminate when ``tr_radius < xtol``, where
+ ``tr_radius`` is the radius of the trust region used in the algorithm.
+ Default is 1e-8.
+ barrier_tol : float, optional
+ Threshold on the barrier parameter for the algorithm termination.
+ When inequality constraints are present, the algorithm will terminate
+ only when the barrier parameter is less than `barrier_tol`.
+ Default is 1e-8.
+ sparse_jacobian : {bool, None}, optional
+ Determines how to represent Jacobians of the constraints. If bool,
+ then Jacobians of all the constraints will be converted to the
+ corresponding format. If None (default), then Jacobians won't be
+ converted, but the algorithm can proceed only if they all have the
+ same format.
+ initial_tr_radius: float, optional
+ Initial trust radius. The trust radius gives the maximum distance
+ between solution points in consecutive iterations. It reflects the
+ trust the algorithm puts in the local approximation of the optimization
+ problem. For an accurate local approximation the trust-region should be
+ large and for an approximation valid only close to the current point it
+ should be a small one. The trust radius is automatically updated throughout
+ the optimization process, with ``initial_tr_radius`` being its initial value.
+ Default is 1 (recommended in [1]_, p. 19).
+ initial_constr_penalty : float, optional
+ Initial constraints penalty parameter. The penalty parameter is used for
+ balancing the requirements of decreasing the objective function
+ and satisfying the constraints. It is used for defining the merit function:
+ ``merit_function(x) = fun(x) + constr_penalty * constr_norm_l2(x)``,
+ where ``constr_norm_l2(x)`` is the l2 norm of a vector containing all
+ the constraints. The merit function is used for accepting or rejecting
+ trial points and ``constr_penalty`` weights the two conflicting goals
+ of reducing objective function and constraints. The penalty is automatically
+ updated throughout the optimization process, with
+ ``initial_constr_penalty`` being its initial value. Default is 1
+ (recommended in [1]_, p 19).
+ initial_barrier_parameter, initial_barrier_tolerance: float, optional
+ Initial barrier parameter and initial tolerance for the barrier subproblem.
+ Both are used only when inequality constraints are present. For dealing with
+ optimization problems ``min_x f(x)`` subject to inequality constraints
+ ``c(x) <= 0`` the algorithm introduces slack variables, solving the problem
+ ``min_(x,s) f(x) + barrier_parameter*sum(ln(s))`` subject to the equality
+ constraints ``c(x) + s = 0`` instead of the original problem. This subproblem
+ is solved for decreasing values of ``barrier_parameter`` and with decreasing
+ tolerances for the termination, starting with ``initial_barrier_parameter``
+ for the barrier parameter and ``initial_barrier_tolerance`` for the
+ barrier tolerance. Default is 0.1 for both values (recommended in [1]_ p. 19).
+ Also note that ``barrier_parameter`` and ``barrier_tolerance`` are updated
+ with the same prefactor.
+ factorization_method : string or None, optional
+ Method to factorize the Jacobian of the constraints. Use None (default)
+ for the auto selection or one of:
+
+ - 'NormalEquation' (requires scikit-sparse)
+ - 'AugmentedSystem'
+ - 'QRFactorization'
+ - 'SVDFactorization'
+
+ The methods 'NormalEquation' and 'AugmentedSystem' can be used only
+ with sparse constraints. The projections required by the algorithm
+ will be computed using, respectively, the normal equation and the
+ augmented system approaches explained in [1]_. 'NormalEquation'
+ computes the Cholesky factorization of ``A A.T`` and 'AugmentedSystem'
+ performs the LU factorization of an augmented system. They usually
+ provide similar results. 'AugmentedSystem' is used by default for
+ sparse matrices.
+
+ The methods 'QRFactorization' and 'SVDFactorization' can be used
+ only with dense constraints. They compute the required projections
+ using, respectively, QR and SVD factorizations. The 'SVDFactorization'
+ method can cope with Jacobian matrices with deficient row rank and will
+ be used whenever other factorization methods fail (which may imply the
+ conversion of sparse matrices to a dense format when required).
+ By default, 'QRFactorization' is used for dense matrices.
+ finite_diff_rel_step : None or array_like, optional
+ Relative step size for the finite difference approximation.
+ maxiter : int, optional
+ Maximum number of algorithm iterations. Default is 1000.
+ verbose : {0, 1, 2}, optional
+ Level of algorithm's verbosity:
+
+ * 0 (default) : work silently.
+ * 1 : display a termination report.
+ * 2 : display progress during iterations.
+ * 3 : display progress during iterations (more complete report).
+
+ disp : bool, optional
+ If True (default), then `verbose` will be set to 1 if it was 0.
+
+ Returns
+ -------
+ `OptimizeResult` with the fields documented below. Note the following:
+
+ 1. All values corresponding to the constraints are ordered as they
+ were passed to the solver. And values corresponding to `bounds`
+ constraints are put *after* other constraints.
+ 2. All numbers of function, Jacobian or Hessian evaluations correspond
+ to numbers of actual Python function calls. It means, for example,
+ that if a Jacobian is estimated by finite differences, then the
+ number of Jacobian evaluations will be zero and the number of
+ function evaluations will be incremented by all calls during the
+ finite difference estimation.
+
+ x : ndarray, shape (n,)
+ Solution found.
+ optimality : float
+ Infinity norm of the Lagrangian gradient at the solution.
+ constr_violation : float
+ Maximum constraint violation at the solution.
+ fun : float
+ Objective function at the solution.
+ grad : ndarray, shape (n,)
+ Gradient of the objective function at the solution.
+ lagrangian_grad : ndarray, shape (n,)
+ Gradient of the Lagrangian function at the solution.
+ nit : int
+ Total number of iterations.
+ nfev : integer
+ Number of the objective function evaluations.
+ njev : integer
+ Number of the objective function gradient evaluations.
+ nhev : integer
+ Number of the objective function Hessian evaluations.
+ cg_niter : int
+ Total number of the conjugate gradient method iterations.
+ method : {'equality_constrained_sqp', 'tr_interior_point'}
+ Optimization method used.
+ constr : list of ndarray
+ List of constraint values at the solution.
+ jac : list of {ndarray, sparse matrix}
+ List of the Jacobian matrices of the constraints at the solution.
+ v : list of ndarray
+ List of the Lagrange multipliers for the constraints at the solution.
+ For an inequality constraint a positive multiplier means that the upper
+ bound is active, a negative multiplier means that the lower bound is
+ active and if a multiplier is zero it means the constraint is not
+ active.
+ constr_nfev : list of int
+ Number of constraint evaluations for each of the constraints.
+ constr_njev : list of int
+ Number of Jacobian matrix evaluations for each of the constraints.
+ constr_nhev : list of int
+ Number of Hessian evaluations for each of the constraints.
+ tr_radius : float
+ Radius of the trust region at the last iteration.
+ constr_penalty : float
+ Penalty parameter at the last iteration, see `initial_constr_penalty`.
+ barrier_tolerance : float
+ Tolerance for the barrier subproblem at the last iteration.
+ Only for problems with inequality constraints.
+ barrier_parameter : float
+ Barrier parameter at the last iteration. Only for problems
+ with inequality constraints.
+ execution_time : float
+ Total execution time.
+ message : str
+ Termination message.
+ status : {0, 1, 2, 3}
+ Termination status:
+
+ * 0 : The maximum number of function evaluations is exceeded.
+ * 1 : `gtol` termination condition is satisfied.
+ * 2 : `xtol` termination condition is satisfied.
+ * 3 : `callback` function requested termination.
+
+ cg_stop_cond : int
+ Reason for CG subproblem termination at the last iteration:
+
+ * 0 : CG subproblem not evaluated.
+ * 1 : Iteration limit was reached.
+ * 2 : Reached the trust-region boundary.
+ * 3 : Negative curvature detected.
+ * 4 : Tolerance was satisfied.
+
+ References
+ ----------
+ .. [1] Conn, A. R., Gould, N. I., & Toint, P. L.
+ Trust region methods. 2000. Siam. pp. 19.
+ """
+ x0 = np.atleast_1d(x0).astype(float)
+ n_vars = np.size(x0)
+ if hess is None:
+ if callable(hessp):
+ hess = HessianLinearOperator(hessp, n_vars)
+ else:
+ hess = BFGS()
+ if disp and verbose == 0:
+ verbose = 1
+
+ if bounds is not None:
+ modified_lb = np.nextafter(bounds.lb, -np.inf, where=bounds.lb > -np.inf)
+ modified_ub = np.nextafter(bounds.ub, np.inf, where=bounds.ub < np.inf)
+ modified_lb = np.where(np.isfinite(bounds.lb), modified_lb, bounds.lb)
+ modified_ub = np.where(np.isfinite(bounds.ub), modified_ub, bounds.ub)
+ bounds = Bounds(modified_lb, modified_ub, keep_feasible=bounds.keep_feasible)
+ finite_diff_bounds = strict_bounds(bounds.lb, bounds.ub,
+ bounds.keep_feasible, n_vars)
+ else:
+ finite_diff_bounds = (-np.inf, np.inf)
+
+ # Define Objective Function
+ objective = ScalarFunction(fun, x0, args, grad, hess,
+ finite_diff_rel_step, finite_diff_bounds)
+
+ # Put constraints in list format when needed.
+ if isinstance(constraints, (NonlinearConstraint, LinearConstraint)):
+ constraints = [constraints]
+
+ # Prepare constraints.
+ prepared_constraints = [
+ PreparedConstraint(c, x0, sparse_jacobian, finite_diff_bounds)
+ for c in constraints]
+
+ # Check that all constraints are either sparse or dense.
+ n_sparse = sum(c.fun.sparse_jacobian for c in prepared_constraints)
+ if 0 < n_sparse < len(prepared_constraints):
+ raise ValueError("All constraints must have the same kind of the "
+ "Jacobian --- either all sparse or all dense. "
+ "You can set the sparsity globally by setting "
+ "`sparse_jacobian` to either True of False.")
+ if prepared_constraints:
+ sparse_jacobian = n_sparse > 0
+
+ if bounds is not None:
+ if sparse_jacobian is None:
+ sparse_jacobian = True
+ prepared_constraints.append(PreparedConstraint(bounds, x0,
+ sparse_jacobian))
+
+ # Concatenate initial constraints to the canonical form.
+ c_eq0, c_ineq0, J_eq0, J_ineq0 = initial_constraints_as_canonical(
+ n_vars, prepared_constraints, sparse_jacobian)
+
+ # Prepare all canonical constraints and concatenate it into one.
+ canonical_all = [CanonicalConstraint.from_PreparedConstraint(c)
+ for c in prepared_constraints]
+
+ if len(canonical_all) == 0:
+ canonical = CanonicalConstraint.empty(n_vars)
+ elif len(canonical_all) == 1:
+ canonical = canonical_all[0]
+ else:
+ canonical = CanonicalConstraint.concatenate(canonical_all,
+ sparse_jacobian)
+
+ # Generate the Hessian of the Lagrangian.
+ lagrangian_hess = LagrangianHessian(n_vars, objective.hess, canonical.hess)
+
+ # Choose appropriate method
+ if canonical.n_ineq == 0:
+ method = 'equality_constrained_sqp'
+ else:
+ method = 'tr_interior_point'
+
+ # Construct OptimizeResult
+ state = OptimizeResult(
+ nit=0, nfev=0, njev=0, nhev=0,
+ cg_niter=0, cg_stop_cond=0,
+ fun=objective.f, grad=objective.g,
+ lagrangian_grad=np.copy(objective.g),
+ constr=[c.fun.f for c in prepared_constraints],
+ jac=[c.fun.J for c in prepared_constraints],
+ constr_nfev=[0 for c in prepared_constraints],
+ constr_njev=[0 for c in prepared_constraints],
+ constr_nhev=[0 for c in prepared_constraints],
+ v=[c.fun.v for c in prepared_constraints],
+ method=method)
+
+ # Start counting
+ start_time = time.time()
+
+ # Define stop criteria
+ if method == 'equality_constrained_sqp':
+ def stop_criteria(state, x, last_iteration_failed,
+ optimality, constr_violation,
+ tr_radius, constr_penalty, cg_info):
+ state = update_state_sqp(state, x, last_iteration_failed,
+ objective, prepared_constraints,
+ start_time, tr_radius, constr_penalty,
+ cg_info)
+ if verbose == 2:
+ BasicReport.print_iteration(state.nit,
+ state.nfev,
+ state.cg_niter,
+ state.fun,
+ state.tr_radius,
+ state.optimality,
+ state.constr_violation)
+ elif verbose > 2:
+ SQPReport.print_iteration(state.nit,
+ state.nfev,
+ state.cg_niter,
+ state.fun,
+ state.tr_radius,
+ state.optimality,
+ state.constr_violation,
+ state.constr_penalty,
+ state.cg_stop_cond)
+ state.status = None
+ state.niter = state.nit # Alias for callback (backward-compatibility)
+ if callback is not None:
+ callback_stop = False
+ try:
+ callback_stop = callback(state)
+ except StopIteration:
+ callback_stop = True
+ if callback_stop:
+ state.status = 3
+ return True
+ if state.optimality < gtol and state.constr_violation < gtol:
+ state.status = 1
+ elif state.tr_radius < xtol:
+ state.status = 2
+ elif state.nit >= maxiter:
+ state.status = 0
+ return state.status in (0, 1, 2, 3)
+ elif method == 'tr_interior_point':
+ def stop_criteria(state, x, last_iteration_failed, tr_radius,
+ constr_penalty, cg_info, barrier_parameter,
+ barrier_tolerance):
+ state = update_state_ip(state, x, last_iteration_failed,
+ objective, prepared_constraints,
+ start_time, tr_radius, constr_penalty,
+ cg_info, barrier_parameter, barrier_tolerance)
+ if verbose == 2:
+ BasicReport.print_iteration(state.nit,
+ state.nfev,
+ state.cg_niter,
+ state.fun,
+ state.tr_radius,
+ state.optimality,
+ state.constr_violation)
+ elif verbose > 2:
+ IPReport.print_iteration(state.nit,
+ state.nfev,
+ state.cg_niter,
+ state.fun,
+ state.tr_radius,
+ state.optimality,
+ state.constr_violation,
+ state.constr_penalty,
+ state.barrier_parameter,
+ state.cg_stop_cond)
+ state.status = None
+ state.niter = state.nit # Alias for callback (backward compatibility)
+ if callback is not None:
+ callback_stop = False
+ try:
+ callback_stop = callback(state)
+ except StopIteration:
+ callback_stop = True
+ if callback_stop:
+ state.status = 3
+ return True
+ if state.optimality < gtol and state.constr_violation < gtol:
+ state.status = 1
+ elif (state.tr_radius < xtol
+ and state.barrier_parameter < barrier_tol):
+ state.status = 2
+ elif state.nit >= maxiter:
+ state.status = 0
+ return state.status in (0, 1, 2, 3)
+
+ if verbose == 2:
+ BasicReport.print_header()
+ elif verbose > 2:
+ if method == 'equality_constrained_sqp':
+ SQPReport.print_header()
+ elif method == 'tr_interior_point':
+ IPReport.print_header()
+
+ # Call inferior function to do the optimization
+ if method == 'equality_constrained_sqp':
+ def fun_and_constr(x):
+ f = objective.fun(x)
+ c_eq, _ = canonical.fun(x)
+ return f, c_eq
+
+ def grad_and_jac(x):
+ g = objective.grad(x)
+ J_eq, _ = canonical.jac(x)
+ return g, J_eq
+
+ _, result = equality_constrained_sqp(
+ fun_and_constr, grad_and_jac, lagrangian_hess,
+ x0, objective.f, objective.g,
+ c_eq0, J_eq0,
+ stop_criteria, state,
+ initial_constr_penalty, initial_tr_radius,
+ factorization_method)
+
+ elif method == 'tr_interior_point':
+ _, result = tr_interior_point(
+ objective.fun, objective.grad, lagrangian_hess,
+ n_vars, canonical.n_ineq, canonical.n_eq,
+ canonical.fun, canonical.jac,
+ x0, objective.f, objective.g,
+ c_ineq0, J_ineq0, c_eq0, J_eq0,
+ stop_criteria,
+ canonical.keep_feasible,
+ xtol, state, initial_barrier_parameter,
+ initial_barrier_tolerance,
+ initial_constr_penalty, initial_tr_radius,
+ factorization_method)
+
+ # Status 3 occurs when the callback function requests termination,
+ # this is assumed to not be a success.
+ result.success = True if result.status in (1, 2) else False
+ result.message = TERMINATION_MESSAGES[result.status]
+
+ # Alias (for backward compatibility with 1.1.0)
+ result.niter = result.nit
+
+ if verbose == 2:
+ BasicReport.print_footer()
+ elif verbose > 2:
+ if method == 'equality_constrained_sqp':
+ SQPReport.print_footer()
+ elif method == 'tr_interior_point':
+ IPReport.print_footer()
+ if verbose >= 1:
+ print(result.message)
+ print("Number of iterations: {}, function evaluations: {}, "
+ "CG iterations: {}, optimality: {:.2e}, "
+ "constraint violation: {:.2e}, execution time: {:4.2} s."
+ .format(result.nit, result.nfev, result.cg_niter,
+ result.optimality, result.constr_violation,
+ result.execution_time))
+ return result
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/projections.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/projections.py
new file mode 100644
index 0000000000000000000000000000000000000000..a07b836bdbad688a265ae34ce91a361fd5050eb1
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/projections.py
@@ -0,0 +1,407 @@
+"""Basic linear factorizations needed by the solver."""
+
+from scipy.sparse import (bmat, csc_matrix, eye, issparse)
+from scipy.sparse.linalg import LinearOperator
+import scipy.linalg
+import scipy.sparse.linalg
+try:
+ from sksparse.cholmod import cholesky_AAt
+ sksparse_available = True
+except ImportError:
+ import warnings
+ sksparse_available = False
+import numpy as np
+from warnings import warn
+
+__all__ = [
+ 'orthogonality',
+ 'projections',
+]
+
+
+def orthogonality(A, g):
+ """Measure orthogonality between a vector and the null space of a matrix.
+
+ Compute a measure of orthogonality between the null space
+ of the (possibly sparse) matrix ``A`` and a given vector ``g``.
+
+ The formula is a simplified (and cheaper) version of formula (3.13)
+ from [1]_.
+ ``orth = norm(A g, ord=2)/(norm(A, ord='fro')*norm(g, ord=2))``.
+
+ References
+ ----------
+ .. [1] Gould, Nicholas IM, Mary E. Hribar, and Jorge Nocedal.
+ "On the solution of equality constrained quadratic
+ programming problems arising in optimization."
+ SIAM Journal on Scientific Computing 23.4 (2001): 1376-1395.
+ """
+ # Compute vector norms
+ norm_g = np.linalg.norm(g)
+ # Compute Froebnius norm of the matrix A
+ if issparse(A):
+ norm_A = scipy.sparse.linalg.norm(A, ord='fro')
+ else:
+ norm_A = np.linalg.norm(A, ord='fro')
+
+ # Check if norms are zero
+ if norm_g == 0 or norm_A == 0:
+ return 0
+
+ norm_A_g = np.linalg.norm(A.dot(g))
+ # Orthogonality measure
+ orth = norm_A_g / (norm_A*norm_g)
+ return orth
+
+
+def normal_equation_projections(A, m, n, orth_tol, max_refin, tol):
+ """Return linear operators for matrix A using ``NormalEquation`` approach.
+ """
+ # Cholesky factorization
+ factor = cholesky_AAt(A)
+
+ # z = x - A.T inv(A A.T) A x
+ def null_space(x):
+ v = factor(A.dot(x))
+ z = x - A.T.dot(v)
+
+ # Iterative refinement to improve roundoff
+ # errors described in [2]_, algorithm 5.1.
+ k = 0
+ while orthogonality(A, z) > orth_tol:
+ if k >= max_refin:
+ break
+ # z_next = z - A.T inv(A A.T) A z
+ v = factor(A.dot(z))
+ z = z - A.T.dot(v)
+ k += 1
+
+ return z
+
+ # z = inv(A A.T) A x
+ def least_squares(x):
+ return factor(A.dot(x))
+
+ # z = A.T inv(A A.T) x
+ def row_space(x):
+ return A.T.dot(factor(x))
+
+ return null_space, least_squares, row_space
+
+
+def augmented_system_projections(A, m, n, orth_tol, max_refin, tol):
+ """Return linear operators for matrix A - ``AugmentedSystem``."""
+ # Form augmented system
+ K = csc_matrix(bmat([[eye(n), A.T], [A, None]]))
+ # LU factorization
+ # TODO: Use a symmetric indefinite factorization
+ # to solve the system twice as fast (because
+ # of the symmetry).
+ try:
+ solve = scipy.sparse.linalg.factorized(K)
+ except RuntimeError:
+ warn("Singular Jacobian matrix. Using dense SVD decomposition to "
+ "perform the factorizations.",
+ stacklevel=3)
+ return svd_factorization_projections(A.toarray(),
+ m, n, orth_tol,
+ max_refin, tol)
+
+ # z = x - A.T inv(A A.T) A x
+ # is computed solving the extended system:
+ # [I A.T] * [ z ] = [x]
+ # [A O ] [aux] [0]
+ def null_space(x):
+ # v = [x]
+ # [0]
+ v = np.hstack([x, np.zeros(m)])
+ # lu_sol = [ z ]
+ # [aux]
+ lu_sol = solve(v)
+ z = lu_sol[:n]
+
+ # Iterative refinement to improve roundoff
+ # errors described in [2]_, algorithm 5.2.
+ k = 0
+ while orthogonality(A, z) > orth_tol:
+ if k >= max_refin:
+ break
+ # new_v = [x] - [I A.T] * [ z ]
+ # [0] [A O ] [aux]
+ new_v = v - K.dot(lu_sol)
+ # [I A.T] * [delta z ] = new_v
+ # [A O ] [delta aux]
+ lu_update = solve(new_v)
+ # [ z ] += [delta z ]
+ # [aux] [delta aux]
+ lu_sol += lu_update
+ z = lu_sol[:n]
+ k += 1
+
+ # return z = x - A.T inv(A A.T) A x
+ return z
+
+ # z = inv(A A.T) A x
+ # is computed solving the extended system:
+ # [I A.T] * [aux] = [x]
+ # [A O ] [ z ] [0]
+ def least_squares(x):
+ # v = [x]
+ # [0]
+ v = np.hstack([x, np.zeros(m)])
+ # lu_sol = [aux]
+ # [ z ]
+ lu_sol = solve(v)
+ # return z = inv(A A.T) A x
+ return lu_sol[n:m+n]
+
+ # z = A.T inv(A A.T) x
+ # is computed solving the extended system:
+ # [I A.T] * [ z ] = [0]
+ # [A O ] [aux] [x]
+ def row_space(x):
+ # v = [0]
+ # [x]
+ v = np.hstack([np.zeros(n), x])
+ # lu_sol = [ z ]
+ # [aux]
+ lu_sol = solve(v)
+ # return z = A.T inv(A A.T) x
+ return lu_sol[:n]
+
+ return null_space, least_squares, row_space
+
+
+def qr_factorization_projections(A, m, n, orth_tol, max_refin, tol):
+ """Return linear operators for matrix A using ``QRFactorization`` approach.
+ """
+ # QRFactorization
+ Q, R, P = scipy.linalg.qr(A.T, pivoting=True, mode='economic')
+
+ if np.linalg.norm(R[-1, :], np.inf) < tol:
+ warn('Singular Jacobian matrix. Using SVD decomposition to ' +
+ 'perform the factorizations.',
+ stacklevel=3)
+ return svd_factorization_projections(A, m, n,
+ orth_tol,
+ max_refin,
+ tol)
+
+ # z = x - A.T inv(A A.T) A x
+ def null_space(x):
+ # v = P inv(R) Q.T x
+ aux1 = Q.T.dot(x)
+ aux2 = scipy.linalg.solve_triangular(R, aux1, lower=False)
+ v = np.zeros(m)
+ v[P] = aux2
+ z = x - A.T.dot(v)
+
+ # Iterative refinement to improve roundoff
+ # errors described in [2]_, algorithm 5.1.
+ k = 0
+ while orthogonality(A, z) > orth_tol:
+ if k >= max_refin:
+ break
+ # v = P inv(R) Q.T x
+ aux1 = Q.T.dot(z)
+ aux2 = scipy.linalg.solve_triangular(R, aux1, lower=False)
+ v[P] = aux2
+ # z_next = z - A.T v
+ z = z - A.T.dot(v)
+ k += 1
+
+ return z
+
+ # z = inv(A A.T) A x
+ def least_squares(x):
+ # z = P inv(R) Q.T x
+ aux1 = Q.T.dot(x)
+ aux2 = scipy.linalg.solve_triangular(R, aux1, lower=False)
+ z = np.zeros(m)
+ z[P] = aux2
+ return z
+
+ # z = A.T inv(A A.T) x
+ def row_space(x):
+ # z = Q inv(R.T) P.T x
+ aux1 = x[P]
+ aux2 = scipy.linalg.solve_triangular(R, aux1,
+ lower=False,
+ trans='T')
+ z = Q.dot(aux2)
+ return z
+
+ return null_space, least_squares, row_space
+
+
+def svd_factorization_projections(A, m, n, orth_tol, max_refin, tol):
+ """Return linear operators for matrix A using ``SVDFactorization`` approach.
+ """
+ # SVD Factorization
+ U, s, Vt = scipy.linalg.svd(A, full_matrices=False)
+
+ # Remove dimensions related with very small singular values
+ U = U[:, s > tol]
+ Vt = Vt[s > tol, :]
+ s = s[s > tol]
+
+ # z = x - A.T inv(A A.T) A x
+ def null_space(x):
+ # v = U 1/s V.T x = inv(A A.T) A x
+ aux1 = Vt.dot(x)
+ aux2 = 1/s*aux1
+ v = U.dot(aux2)
+ z = x - A.T.dot(v)
+
+ # Iterative refinement to improve roundoff
+ # errors described in [2]_, algorithm 5.1.
+ k = 0
+ while orthogonality(A, z) > orth_tol:
+ if k >= max_refin:
+ break
+ # v = U 1/s V.T x = inv(A A.T) A x
+ aux1 = Vt.dot(z)
+ aux2 = 1/s*aux1
+ v = U.dot(aux2)
+ # z_next = z - A.T v
+ z = z - A.T.dot(v)
+ k += 1
+
+ return z
+
+ # z = inv(A A.T) A x
+ def least_squares(x):
+ # z = U 1/s V.T x = inv(A A.T) A x
+ aux1 = Vt.dot(x)
+ aux2 = 1/s*aux1
+ z = U.dot(aux2)
+ return z
+
+ # z = A.T inv(A A.T) x
+ def row_space(x):
+ # z = V 1/s U.T x
+ aux1 = U.T.dot(x)
+ aux2 = 1/s*aux1
+ z = Vt.T.dot(aux2)
+ return z
+
+ return null_space, least_squares, row_space
+
+
+def projections(A, method=None, orth_tol=1e-12, max_refin=3, tol=1e-15):
+ """Return three linear operators related with a given matrix A.
+
+ Parameters
+ ----------
+ A : sparse matrix (or ndarray), shape (m, n)
+ Matrix ``A`` used in the projection.
+ method : string, optional
+ Method used for compute the given linear
+ operators. Should be one of:
+
+ - 'NormalEquation': The operators
+ will be computed using the
+ so-called normal equation approach
+ explained in [1]_. In order to do
+ so the Cholesky factorization of
+ ``(A A.T)`` is computed. Exclusive
+ for sparse matrices.
+ - 'AugmentedSystem': The operators
+ will be computed using the
+ so-called augmented system approach
+ explained in [1]_. Exclusive
+ for sparse matrices.
+ - 'QRFactorization': Compute projections
+ using QR factorization. Exclusive for
+ dense matrices.
+ - 'SVDFactorization': Compute projections
+ using SVD factorization. Exclusive for
+ dense matrices.
+
+ orth_tol : float, optional
+ Tolerance for iterative refinements.
+ max_refin : int, optional
+ Maximum number of iterative refinements.
+ tol : float, optional
+ Tolerance for singular values.
+
+ Returns
+ -------
+ Z : LinearOperator, shape (n, n)
+ Null-space operator. For a given vector ``x``,
+ the null space operator is equivalent to apply
+ a projection matrix ``P = I - A.T inv(A A.T) A``
+ to the vector. It can be shown that this is
+ equivalent to project ``x`` into the null space
+ of A.
+ LS : LinearOperator, shape (m, n)
+ Least-squares operator. For a given vector ``x``,
+ the least-squares operator is equivalent to apply a
+ pseudoinverse matrix ``pinv(A.T) = inv(A A.T) A``
+ to the vector. It can be shown that this vector
+ ``pinv(A.T) x`` is the least_square solution to
+ ``A.T y = x``.
+ Y : LinearOperator, shape (n, m)
+ Row-space operator. For a given vector ``x``,
+ the row-space operator is equivalent to apply a
+ projection matrix ``Q = A.T inv(A A.T)``
+ to the vector. It can be shown that this
+ vector ``y = Q x`` the minimum norm solution
+ of ``A y = x``.
+
+ Notes
+ -----
+ Uses iterative refinements described in [1]
+ during the computation of ``Z`` in order to
+ cope with the possibility of large roundoff errors.
+
+ References
+ ----------
+ .. [1] Gould, Nicholas IM, Mary E. Hribar, and Jorge Nocedal.
+ "On the solution of equality constrained quadratic
+ programming problems arising in optimization."
+ SIAM Journal on Scientific Computing 23.4 (2001): 1376-1395.
+ """
+ m, n = np.shape(A)
+
+ # The factorization of an empty matrix
+ # only works for the sparse representation.
+ if m*n == 0:
+ A = csc_matrix(A)
+
+ # Check Argument
+ if issparse(A):
+ if method is None:
+ method = "AugmentedSystem"
+ if method not in ("NormalEquation", "AugmentedSystem"):
+ raise ValueError("Method not allowed for sparse matrix.")
+ if method == "NormalEquation" and not sksparse_available:
+ warnings.warn("Only accepts 'NormalEquation' option when "
+ "scikit-sparse is available. Using "
+ "'AugmentedSystem' option instead.",
+ ImportWarning, stacklevel=3)
+ method = 'AugmentedSystem'
+ else:
+ if method is None:
+ method = "QRFactorization"
+ if method not in ("QRFactorization", "SVDFactorization"):
+ raise ValueError("Method not allowed for dense array.")
+
+ if method == 'NormalEquation':
+ null_space, least_squares, row_space \
+ = normal_equation_projections(A, m, n, orth_tol, max_refin, tol)
+ elif method == 'AugmentedSystem':
+ null_space, least_squares, row_space \
+ = augmented_system_projections(A, m, n, orth_tol, max_refin, tol)
+ elif method == "QRFactorization":
+ null_space, least_squares, row_space \
+ = qr_factorization_projections(A, m, n, orth_tol, max_refin, tol)
+ elif method == "SVDFactorization":
+ null_space, least_squares, row_space \
+ = svd_factorization_projections(A, m, n, orth_tol, max_refin, tol)
+
+ Z = LinearOperator((n, n), null_space)
+ LS = LinearOperator((m, n), least_squares)
+ Y = LinearOperator((n, m), row_space)
+
+ return Z, LS, Y
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/qp_subproblem.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/qp_subproblem.py
new file mode 100644
index 0000000000000000000000000000000000000000..a039a7738c283f90f30fd7c4583bf9e1a8f559d5
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/qp_subproblem.py
@@ -0,0 +1,637 @@
+"""Equality-constrained quadratic programming solvers."""
+
+from scipy.sparse import (linalg, bmat, csc_matrix)
+from math import copysign
+import numpy as np
+from numpy.linalg import norm
+
+__all__ = [
+ 'eqp_kktfact',
+ 'sphere_intersections',
+ 'box_intersections',
+ 'box_sphere_intersections',
+ 'inside_box_boundaries',
+ 'modified_dogleg',
+ 'projected_cg'
+]
+
+
+# For comparison with the projected CG
+def eqp_kktfact(H, c, A, b):
+ """Solve equality-constrained quadratic programming (EQP) problem.
+
+ Solve ``min 1/2 x.T H x + x.t c`` subject to ``A x + b = 0``
+ using direct factorization of the KKT system.
+
+ Parameters
+ ----------
+ H : sparse matrix, shape (n, n)
+ Hessian matrix of the EQP problem.
+ c : array_like, shape (n,)
+ Gradient of the quadratic objective function.
+ A : sparse matrix
+ Jacobian matrix of the EQP problem.
+ b : array_like, shape (m,)
+ Right-hand side of the constraint equation.
+
+ Returns
+ -------
+ x : array_like, shape (n,)
+ Solution of the KKT problem.
+ lagrange_multipliers : ndarray, shape (m,)
+ Lagrange multipliers of the KKT problem.
+ """
+ n, = np.shape(c) # Number of parameters
+ m, = np.shape(b) # Number of constraints
+
+ # Karush-Kuhn-Tucker matrix of coefficients.
+ # Defined as in Nocedal/Wright "Numerical
+ # Optimization" p.452 in Eq. (16.4).
+ kkt_matrix = csc_matrix(bmat([[H, A.T], [A, None]]))
+ # Vector of coefficients.
+ kkt_vec = np.hstack([-c, -b])
+
+ # TODO: Use a symmetric indefinite factorization
+ # to solve the system twice as fast (because
+ # of the symmetry).
+ lu = linalg.splu(kkt_matrix)
+ kkt_sol = lu.solve(kkt_vec)
+ x = kkt_sol[:n]
+ lagrange_multipliers = -kkt_sol[n:n+m]
+
+ return x, lagrange_multipliers
+
+
+def sphere_intersections(z, d, trust_radius,
+ entire_line=False):
+ """Find the intersection between segment (or line) and spherical constraints.
+
+ Find the intersection between the segment (or line) defined by the
+ parametric equation ``x(t) = z + t*d`` and the ball
+ ``||x|| <= trust_radius``.
+
+ Parameters
+ ----------
+ z : array_like, shape (n,)
+ Initial point.
+ d : array_like, shape (n,)
+ Direction.
+ trust_radius : float
+ Ball radius.
+ entire_line : bool, optional
+ When ``True``, the function returns the intersection between the line
+ ``x(t) = z + t*d`` (``t`` can assume any value) and the ball
+ ``||x|| <= trust_radius``. When ``False``, the function returns the intersection
+ between the segment ``x(t) = z + t*d``, ``0 <= t <= 1``, and the ball.
+
+ Returns
+ -------
+ ta, tb : float
+ The line/segment ``x(t) = z + t*d`` is inside the ball for
+ for ``ta <= t <= tb``.
+ intersect : bool
+ When ``True``, there is a intersection between the line/segment
+ and the sphere. On the other hand, when ``False``, there is no
+ intersection.
+ """
+ # Special case when d=0
+ if norm(d) == 0:
+ return 0, 0, False
+ # Check for inf trust_radius
+ if np.isinf(trust_radius):
+ if entire_line:
+ ta = -np.inf
+ tb = np.inf
+ else:
+ ta = 0
+ tb = 1
+ intersect = True
+ return ta, tb, intersect
+
+ a = np.dot(d, d)
+ b = 2 * np.dot(z, d)
+ c = np.dot(z, z) - trust_radius**2
+ discriminant = b*b - 4*a*c
+ if discriminant < 0:
+ intersect = False
+ return 0, 0, intersect
+ sqrt_discriminant = np.sqrt(discriminant)
+
+ # The following calculation is mathematically
+ # equivalent to:
+ # ta = (-b - sqrt_discriminant) / (2*a)
+ # tb = (-b + sqrt_discriminant) / (2*a)
+ # but produce smaller round off errors.
+ # Look at Matrix Computation p.97
+ # for a better justification.
+ aux = b + copysign(sqrt_discriminant, b)
+ ta = -aux / (2*a)
+ tb = -2*c / aux
+ ta, tb = sorted([ta, tb])
+
+ if entire_line:
+ intersect = True
+ else:
+ # Checks to see if intersection happens
+ # within vectors length.
+ if tb < 0 or ta > 1:
+ intersect = False
+ ta = 0
+ tb = 0
+ else:
+ intersect = True
+ # Restrict intersection interval
+ # between 0 and 1.
+ ta = max(0, ta)
+ tb = min(1, tb)
+
+ return ta, tb, intersect
+
+
+def box_intersections(z, d, lb, ub,
+ entire_line=False):
+ """Find the intersection between segment (or line) and box constraints.
+
+ Find the intersection between the segment (or line) defined by the
+ parametric equation ``x(t) = z + t*d`` and the rectangular box
+ ``lb <= x <= ub``.
+
+ Parameters
+ ----------
+ z : array_like, shape (n,)
+ Initial point.
+ d : array_like, shape (n,)
+ Direction.
+ lb : array_like, shape (n,)
+ Lower bounds to each one of the components of ``x``. Used
+ to delimit the rectangular box.
+ ub : array_like, shape (n, )
+ Upper bounds to each one of the components of ``x``. Used
+ to delimit the rectangular box.
+ entire_line : bool, optional
+ When ``True``, the function returns the intersection between the line
+ ``x(t) = z + t*d`` (``t`` can assume any value) and the rectangular
+ box. When ``False``, the function returns the intersection between the segment
+ ``x(t) = z + t*d``, ``0 <= t <= 1``, and the rectangular box.
+
+ Returns
+ -------
+ ta, tb : float
+ The line/segment ``x(t) = z + t*d`` is inside the box for
+ for ``ta <= t <= tb``.
+ intersect : bool
+ When ``True``, there is a intersection between the line (or segment)
+ and the rectangular box. On the other hand, when ``False``, there is no
+ intersection.
+ """
+ # Make sure it is a numpy array
+ z = np.asarray(z)
+ d = np.asarray(d)
+ lb = np.asarray(lb)
+ ub = np.asarray(ub)
+ # Special case when d=0
+ if norm(d) == 0:
+ return 0, 0, False
+
+ # Get values for which d==0
+ zero_d = (d == 0)
+ # If the boundaries are not satisfied for some coordinate
+ # for which "d" is zero, there is no box-line intersection.
+ if (z[zero_d] < lb[zero_d]).any() or (z[zero_d] > ub[zero_d]).any():
+ intersect = False
+ return 0, 0, intersect
+ # Remove values for which d is zero
+ not_zero_d = np.logical_not(zero_d)
+ z = z[not_zero_d]
+ d = d[not_zero_d]
+ lb = lb[not_zero_d]
+ ub = ub[not_zero_d]
+
+ # Find a series of intervals (t_lb[i], t_ub[i]).
+ t_lb = (lb-z) / d
+ t_ub = (ub-z) / d
+ # Get the intersection of all those intervals.
+ ta = max(np.minimum(t_lb, t_ub))
+ tb = min(np.maximum(t_lb, t_ub))
+
+ # Check if intersection is feasible
+ if ta <= tb:
+ intersect = True
+ else:
+ intersect = False
+ # Checks to see if intersection happens within vectors length.
+ if not entire_line:
+ if tb < 0 or ta > 1:
+ intersect = False
+ ta = 0
+ tb = 0
+ else:
+ # Restrict intersection interval between 0 and 1.
+ ta = max(0, ta)
+ tb = min(1, tb)
+
+ return ta, tb, intersect
+
+
+def box_sphere_intersections(z, d, lb, ub, trust_radius,
+ entire_line=False,
+ extra_info=False):
+ """Find the intersection between segment (or line) and box/sphere constraints.
+
+ Find the intersection between the segment (or line) defined by the
+ parametric equation ``x(t) = z + t*d``, the rectangular box
+ ``lb <= x <= ub`` and the ball ``||x|| <= trust_radius``.
+
+ Parameters
+ ----------
+ z : array_like, shape (n,)
+ Initial point.
+ d : array_like, shape (n,)
+ Direction.
+ lb : array_like, shape (n,)
+ Lower bounds to each one of the components of ``x``. Used
+ to delimit the rectangular box.
+ ub : array_like, shape (n, )
+ Upper bounds to each one of the components of ``x``. Used
+ to delimit the rectangular box.
+ trust_radius : float
+ Ball radius.
+ entire_line : bool, optional
+ When ``True``, the function returns the intersection between the line
+ ``x(t) = z + t*d`` (``t`` can assume any value) and the constraints.
+ When ``False``, the function returns the intersection between the segment
+ ``x(t) = z + t*d``, ``0 <= t <= 1`` and the constraints.
+ extra_info : bool, optional
+ When ``True``, the function returns ``intersect_sphere`` and ``intersect_box``.
+
+ Returns
+ -------
+ ta, tb : float
+ The line/segment ``x(t) = z + t*d`` is inside the rectangular box and
+ inside the ball for ``ta <= t <= tb``.
+ intersect : bool
+ When ``True``, there is a intersection between the line (or segment)
+ and both constraints. On the other hand, when ``False``, there is no
+ intersection.
+ sphere_info : dict, optional
+ Dictionary ``{ta, tb, intersect}`` containing the interval ``[ta, tb]``
+ for which the line intercepts the ball. And a boolean value indicating
+ whether the sphere is intersected by the line.
+ box_info : dict, optional
+ Dictionary ``{ta, tb, intersect}`` containing the interval ``[ta, tb]``
+ for which the line intercepts the box. And a boolean value indicating
+ whether the box is intersected by the line.
+ """
+ ta_b, tb_b, intersect_b = box_intersections(z, d, lb, ub,
+ entire_line)
+ ta_s, tb_s, intersect_s = sphere_intersections(z, d,
+ trust_radius,
+ entire_line)
+ ta = np.maximum(ta_b, ta_s)
+ tb = np.minimum(tb_b, tb_s)
+ if intersect_b and intersect_s and ta <= tb:
+ intersect = True
+ else:
+ intersect = False
+
+ if extra_info:
+ sphere_info = {'ta': ta_s, 'tb': tb_s, 'intersect': intersect_s}
+ box_info = {'ta': ta_b, 'tb': tb_b, 'intersect': intersect_b}
+ return ta, tb, intersect, sphere_info, box_info
+ else:
+ return ta, tb, intersect
+
+
+def inside_box_boundaries(x, lb, ub):
+ """Check if lb <= x <= ub."""
+ return (lb <= x).all() and (x <= ub).all()
+
+
+def reinforce_box_boundaries(x, lb, ub):
+ """Return clipped value of x"""
+ return np.minimum(np.maximum(x, lb), ub)
+
+
+def modified_dogleg(A, Y, b, trust_radius, lb, ub):
+ """Approximately minimize ``1/2*|| A x + b ||^2`` inside trust-region.
+
+ Approximately solve the problem of minimizing ``1/2*|| A x + b ||^2``
+ subject to ``||x|| < Delta`` and ``lb <= x <= ub`` using a modification
+ of the classical dogleg approach.
+
+ Parameters
+ ----------
+ A : LinearOperator (or sparse matrix or ndarray), shape (m, n)
+ Matrix ``A`` in the minimization problem. It should have
+ dimension ``(m, n)`` such that ``m < n``.
+ Y : LinearOperator (or sparse matrix or ndarray), shape (n, m)
+ LinearOperator that apply the projection matrix
+ ``Q = A.T inv(A A.T)`` to the vector. The obtained vector
+ ``y = Q x`` being the minimum norm solution of ``A y = x``.
+ b : array_like, shape (m,)
+ Vector ``b``in the minimization problem.
+ trust_radius: float
+ Trust radius to be considered. Delimits a sphere boundary
+ to the problem.
+ lb : array_like, shape (n,)
+ Lower bounds to each one of the components of ``x``.
+ It is expected that ``lb <= 0``, otherwise the algorithm
+ may fail. If ``lb[i] = -Inf``, the lower
+ bound for the ith component is just ignored.
+ ub : array_like, shape (n, )
+ Upper bounds to each one of the components of ``x``.
+ It is expected that ``ub >= 0``, otherwise the algorithm
+ may fail. If ``ub[i] = Inf``, the upper bound for the ith
+ component is just ignored.
+
+ Returns
+ -------
+ x : array_like, shape (n,)
+ Solution to the problem.
+
+ Notes
+ -----
+ Based on implementations described in pp. 885-886 from [1]_.
+
+ References
+ ----------
+ .. [1] Byrd, Richard H., Mary E. Hribar, and Jorge Nocedal.
+ "An interior point algorithm for large-scale nonlinear
+ programming." SIAM Journal on Optimization 9.4 (1999): 877-900.
+ """
+ # Compute minimum norm minimizer of 1/2*|| A x + b ||^2.
+ newton_point = -Y.dot(b)
+ # Check for interior point
+ if inside_box_boundaries(newton_point, lb, ub) \
+ and norm(newton_point) <= trust_radius:
+ x = newton_point
+ return x
+
+ # Compute gradient vector ``g = A.T b``
+ g = A.T.dot(b)
+ # Compute Cauchy point
+ # `cauchy_point = g.T g / (g.T A.T A g)``.
+ A_g = A.dot(g)
+ cauchy_point = -np.dot(g, g) / np.dot(A_g, A_g) * g
+ # Origin
+ origin_point = np.zeros_like(cauchy_point)
+
+ # Check the segment between cauchy_point and newton_point
+ # for a possible solution.
+ z = cauchy_point
+ p = newton_point - cauchy_point
+ _, alpha, intersect = box_sphere_intersections(z, p, lb, ub,
+ trust_radius)
+ if intersect:
+ x1 = z + alpha*p
+ else:
+ # Check the segment between the origin and cauchy_point
+ # for a possible solution.
+ z = origin_point
+ p = cauchy_point
+ _, alpha, _ = box_sphere_intersections(z, p, lb, ub,
+ trust_radius)
+ x1 = z + alpha*p
+
+ # Check the segment between origin and newton_point
+ # for a possible solution.
+ z = origin_point
+ p = newton_point
+ _, alpha, _ = box_sphere_intersections(z, p, lb, ub,
+ trust_radius)
+ x2 = z + alpha*p
+
+ # Return the best solution among x1 and x2.
+ if norm(A.dot(x1) + b) < norm(A.dot(x2) + b):
+ return x1
+ else:
+ return x2
+
+
+def projected_cg(H, c, Z, Y, b, trust_radius=np.inf,
+ lb=None, ub=None, tol=None,
+ max_iter=None, max_infeasible_iter=None,
+ return_all=False):
+ """Solve EQP problem with projected CG method.
+
+ Solve equality-constrained quadratic programming problem
+ ``min 1/2 x.T H x + x.t c`` subject to ``A x + b = 0`` and,
+ possibly, to trust region constraints ``||x|| < trust_radius``
+ and box constraints ``lb <= x <= ub``.
+
+ Parameters
+ ----------
+ H : LinearOperator (or sparse matrix or ndarray), shape (n, n)
+ Operator for computing ``H v``.
+ c : array_like, shape (n,)
+ Gradient of the quadratic objective function.
+ Z : LinearOperator (or sparse matrix or ndarray), shape (n, n)
+ Operator for projecting ``x`` into the null space of A.
+ Y : LinearOperator, sparse matrix, ndarray, shape (n, m)
+ Operator that, for a given a vector ``b``, compute smallest
+ norm solution of ``A x + b = 0``.
+ b : array_like, shape (m,)
+ Right-hand side of the constraint equation.
+ trust_radius : float, optional
+ Trust radius to be considered. By default, uses ``trust_radius=inf``,
+ which means no trust radius at all.
+ lb : array_like, shape (n,), optional
+ Lower bounds to each one of the components of ``x``.
+ If ``lb[i] = -Inf`` the lower bound for the i-th
+ component is just ignored (default).
+ ub : array_like, shape (n, ), optional
+ Upper bounds to each one of the components of ``x``.
+ If ``ub[i] = Inf`` the upper bound for the i-th
+ component is just ignored (default).
+ tol : float, optional
+ Tolerance used to interrupt the algorithm.
+ max_iter : int, optional
+ Maximum algorithm iterations. Where ``max_inter <= n-m``.
+ By default, uses ``max_iter = n-m``.
+ max_infeasible_iter : int, optional
+ Maximum infeasible (regarding box constraints) iterations the
+ algorithm is allowed to take.
+ By default, uses ``max_infeasible_iter = n-m``.
+ return_all : bool, optional
+ When ``true``, return the list of all vectors through the iterations.
+
+ Returns
+ -------
+ x : array_like, shape (n,)
+ Solution of the EQP problem.
+ info : Dict
+ Dictionary containing the following:
+
+ - niter : Number of iterations.
+ - stop_cond : Reason for algorithm termination:
+ 1. Iteration limit was reached;
+ 2. Reached the trust-region boundary;
+ 3. Negative curvature detected;
+ 4. Tolerance was satisfied.
+ - allvecs : List containing all intermediary vectors (optional).
+ - hits_boundary : True if the proposed step is on the boundary
+ of the trust region.
+
+ Notes
+ -----
+ Implementation of Algorithm 6.2 on [1]_.
+
+ In the absence of spherical and box constraints, for sufficient
+ iterations, the method returns a truly optimal result.
+ In the presence of those constraints, the value returned is only
+ a inexpensive approximation of the optimal value.
+
+ References
+ ----------
+ .. [1] Gould, Nicholas IM, Mary E. Hribar, and Jorge Nocedal.
+ "On the solution of equality constrained quadratic
+ programming problems arising in optimization."
+ SIAM Journal on Scientific Computing 23.4 (2001): 1376-1395.
+ """
+ CLOSE_TO_ZERO = 1e-25
+
+ n, = np.shape(c) # Number of parameters
+ m, = np.shape(b) # Number of constraints
+
+ # Initial Values
+ x = Y.dot(-b)
+ r = Z.dot(H.dot(x) + c)
+ g = Z.dot(r)
+ p = -g
+
+ # Store ``x`` value
+ if return_all:
+ allvecs = [x]
+ # Values for the first iteration
+ H_p = H.dot(p)
+ rt_g = norm(g)**2 # g.T g = r.T Z g = r.T g (ref [1]_ p.1389)
+
+ # If x > trust-region the problem does not have a solution.
+ tr_distance = trust_radius - norm(x)
+ if tr_distance < 0:
+ raise ValueError("Trust region problem does not have a solution.")
+ # If x == trust_radius, then x is the solution
+ # to the optimization problem, since x is the
+ # minimum norm solution to Ax=b.
+ elif tr_distance < CLOSE_TO_ZERO:
+ info = {'niter': 0, 'stop_cond': 2, 'hits_boundary': True}
+ if return_all:
+ allvecs.append(x)
+ info['allvecs'] = allvecs
+ return x, info
+
+ # Set default tolerance
+ if tol is None:
+ tol = max(min(0.01 * np.sqrt(rt_g), 0.1 * rt_g), CLOSE_TO_ZERO)
+ # Set default lower and upper bounds
+ if lb is None:
+ lb = np.full(n, -np.inf)
+ if ub is None:
+ ub = np.full(n, np.inf)
+ # Set maximum iterations
+ if max_iter is None:
+ max_iter = n-m
+ max_iter = min(max_iter, n-m)
+ # Set maximum infeasible iterations
+ if max_infeasible_iter is None:
+ max_infeasible_iter = n-m
+
+ hits_boundary = False
+ stop_cond = 1
+ counter = 0
+ last_feasible_x = np.zeros_like(x)
+ k = 0
+ for i in range(max_iter):
+ # Stop criteria - Tolerance : r.T g < tol
+ if rt_g < tol:
+ stop_cond = 4
+ break
+ k += 1
+ # Compute curvature
+ pt_H_p = H_p.dot(p)
+ # Stop criteria - Negative curvature
+ if pt_H_p <= 0:
+ if np.isinf(trust_radius):
+ raise ValueError("Negative curvature not allowed "
+ "for unrestricted problems.")
+ else:
+ # Find intersection with constraints
+ _, alpha, intersect = box_sphere_intersections(
+ x, p, lb, ub, trust_radius, entire_line=True)
+ # Update solution
+ if intersect:
+ x = x + alpha*p
+ # Reinforce variables are inside box constraints.
+ # This is only necessary because of roundoff errors.
+ x = reinforce_box_boundaries(x, lb, ub)
+ # Attribute information
+ stop_cond = 3
+ hits_boundary = True
+ break
+
+ # Get next step
+ alpha = rt_g / pt_H_p
+ x_next = x + alpha*p
+
+ # Stop criteria - Hits boundary
+ if np.linalg.norm(x_next) >= trust_radius:
+ # Find intersection with box constraints
+ _, theta, intersect = box_sphere_intersections(x, alpha*p, lb, ub,
+ trust_radius)
+ # Update solution
+ if intersect:
+ x = x + theta*alpha*p
+ # Reinforce variables are inside box constraints.
+ # This is only necessary because of roundoff errors.
+ x = reinforce_box_boundaries(x, lb, ub)
+ # Attribute information
+ stop_cond = 2
+ hits_boundary = True
+ break
+
+ # Check if ``x`` is inside the box and start counter if it is not.
+ if inside_box_boundaries(x_next, lb, ub):
+ counter = 0
+ else:
+ counter += 1
+ # Whenever outside box constraints keep looking for intersections.
+ if counter > 0:
+ _, theta, intersect = box_sphere_intersections(x, alpha*p, lb, ub,
+ trust_radius)
+ if intersect:
+ last_feasible_x = x + theta*alpha*p
+ # Reinforce variables are inside box constraints.
+ # This is only necessary because of roundoff errors.
+ last_feasible_x = reinforce_box_boundaries(last_feasible_x,
+ lb, ub)
+ counter = 0
+ # Stop after too many infeasible (regarding box constraints) iteration.
+ if counter > max_infeasible_iter:
+ break
+ # Store ``x_next`` value
+ if return_all:
+ allvecs.append(x_next)
+
+ # Update residual
+ r_next = r + alpha*H_p
+ # Project residual g+ = Z r+
+ g_next = Z.dot(r_next)
+ # Compute conjugate direction step d
+ rt_g_next = norm(g_next)**2 # g.T g = r.T g (ref [1]_ p.1389)
+ beta = rt_g_next / rt_g
+ p = - g_next + beta*p
+ # Prepare for next iteration
+ x = x_next
+ g = g_next
+ r = g_next
+ rt_g = norm(g)**2 # g.T g = r.T Z g = r.T g (ref [1]_ p.1389)
+ H_p = H.dot(p)
+
+ if not inside_box_boundaries(x, lb, ub):
+ x = last_feasible_x
+ hits_boundary = True
+ info = {'niter': k, 'stop_cond': stop_cond,
+ 'hits_boundary': hits_boundary}
+ if return_all:
+ info['allvecs'] = allvecs
+ return x, info
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/report.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/report.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c3b2fb4ef5c90da78ae3f181159140e87393dcf
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/report.py
@@ -0,0 +1,51 @@
+"""Progress report printers."""
+
+from __future__ import annotations
+
+class ReportBase:
+ COLUMN_NAMES: list[str] = NotImplemented
+ COLUMN_WIDTHS: list[int] = NotImplemented
+ ITERATION_FORMATS: list[str] = NotImplemented
+
+ @classmethod
+ def print_header(cls):
+ fmt = ("|"
+ + "|".join([f"{{:^{x}}}" for x in cls.COLUMN_WIDTHS])
+ + "|")
+ separators = ['-' * x for x in cls.COLUMN_WIDTHS]
+ print(fmt.format(*cls.COLUMN_NAMES))
+ print(fmt.format(*separators))
+
+ @classmethod
+ def print_iteration(cls, *args):
+ iteration_format = [f"{{:{x}}}" for x in cls.ITERATION_FORMATS]
+ fmt = "|" + "|".join(iteration_format) + "|"
+ print(fmt.format(*args))
+
+ @classmethod
+ def print_footer(cls):
+ print()
+
+
+class BasicReport(ReportBase):
+ COLUMN_NAMES = ["niter", "f evals", "CG iter", "obj func", "tr radius",
+ "opt", "c viol"]
+ COLUMN_WIDTHS = [7, 7, 7, 13, 10, 10, 10]
+ ITERATION_FORMATS = ["^7", "^7", "^7", "^+13.4e",
+ "^10.2e", "^10.2e", "^10.2e"]
+
+
+class SQPReport(ReportBase):
+ COLUMN_NAMES = ["niter", "f evals", "CG iter", "obj func", "tr radius",
+ "opt", "c viol", "penalty", "CG stop"]
+ COLUMN_WIDTHS = [7, 7, 7, 13, 10, 10, 10, 10, 7]
+ ITERATION_FORMATS = ["^7", "^7", "^7", "^+13.4e", "^10.2e", "^10.2e",
+ "^10.2e", "^10.2e", "^7"]
+
+
+class IPReport(ReportBase):
+ COLUMN_NAMES = ["niter", "f evals", "CG iter", "obj func", "tr radius",
+ "opt", "c viol", "penalty", "barrier param", "CG stop"]
+ COLUMN_WIDTHS = [7, 7, 7, 13, 10, 10, 10, 10, 13, 7]
+ ITERATION_FORMATS = ["^7", "^7", "^7", "^+13.4e", "^10.2e", "^10.2e",
+ "^10.2e", "^10.2e", "^13.2e", "^7"]
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/__init__.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/__pycache__/__init__.cpython-310.pyc b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..375959df5e14dfd3fe370a18c5c72d676b0e5369
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/__pycache__/__init__.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/__pycache__/test_projections.cpython-310.pyc b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/__pycache__/test_projections.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4d8a6c6951caa6d58123fe8e5ad43853e4f4a540
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/__pycache__/test_projections.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/__pycache__/test_report.cpython-310.pyc b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/__pycache__/test_report.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4d0381bc8cfb0862fab3a34d04ac142fb33e4be4
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/__pycache__/test_report.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/test_canonical_constraint.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/test_canonical_constraint.py
new file mode 100644
index 0000000000000000000000000000000000000000..452b327d02da3b3bd3fab9592bdef4d56d6aff57
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/test_canonical_constraint.py
@@ -0,0 +1,296 @@
+import numpy as np
+from numpy.testing import assert_array_equal, assert_equal
+from scipy.optimize._constraints import (NonlinearConstraint, Bounds,
+ PreparedConstraint)
+from scipy.optimize._trustregion_constr.canonical_constraint \
+ import CanonicalConstraint, initial_constraints_as_canonical
+
+
+def create_quadratic_function(n, m, rng):
+ a = rng.rand(m)
+ A = rng.rand(m, n)
+ H = rng.rand(m, n, n)
+ HT = np.transpose(H, (1, 2, 0))
+
+ def fun(x):
+ return a + A.dot(x) + 0.5 * H.dot(x).dot(x)
+
+ def jac(x):
+ return A + H.dot(x)
+
+ def hess(x, v):
+ return HT.dot(v)
+
+ return fun, jac, hess
+
+
+def test_bounds_cases():
+ # Test 1: no constraints.
+ user_constraint = Bounds(-np.inf, np.inf)
+ x0 = np.array([-1, 2])
+ prepared_constraint = PreparedConstraint(user_constraint, x0, False)
+ c = CanonicalConstraint.from_PreparedConstraint(prepared_constraint)
+
+ assert_equal(c.n_eq, 0)
+ assert_equal(c.n_ineq, 0)
+
+ c_eq, c_ineq = c.fun(x0)
+ assert_array_equal(c_eq, [])
+ assert_array_equal(c_ineq, [])
+
+ J_eq, J_ineq = c.jac(x0)
+ assert_array_equal(J_eq, np.empty((0, 2)))
+ assert_array_equal(J_ineq, np.empty((0, 2)))
+
+ assert_array_equal(c.keep_feasible, [])
+
+ # Test 2: infinite lower bound.
+ user_constraint = Bounds(-np.inf, [0, np.inf, 1], [False, True, True])
+ x0 = np.array([-1, -2, -3], dtype=float)
+ prepared_constraint = PreparedConstraint(user_constraint, x0, False)
+ c = CanonicalConstraint.from_PreparedConstraint(prepared_constraint)
+
+ assert_equal(c.n_eq, 0)
+ assert_equal(c.n_ineq, 2)
+
+ c_eq, c_ineq = c.fun(x0)
+ assert_array_equal(c_eq, [])
+ assert_array_equal(c_ineq, [-1, -4])
+
+ J_eq, J_ineq = c.jac(x0)
+ assert_array_equal(J_eq, np.empty((0, 3)))
+ assert_array_equal(J_ineq, np.array([[1, 0, 0], [0, 0, 1]]))
+
+ assert_array_equal(c.keep_feasible, [False, True])
+
+ # Test 3: infinite upper bound.
+ user_constraint = Bounds([0, 1, -np.inf], np.inf, [True, False, True])
+ x0 = np.array([1, 2, 3], dtype=float)
+ prepared_constraint = PreparedConstraint(user_constraint, x0, False)
+ c = CanonicalConstraint.from_PreparedConstraint(prepared_constraint)
+
+ assert_equal(c.n_eq, 0)
+ assert_equal(c.n_ineq, 2)
+
+ c_eq, c_ineq = c.fun(x0)
+ assert_array_equal(c_eq, [])
+ assert_array_equal(c_ineq, [-1, -1])
+
+ J_eq, J_ineq = c.jac(x0)
+ assert_array_equal(J_eq, np.empty((0, 3)))
+ assert_array_equal(J_ineq, np.array([[-1, 0, 0], [0, -1, 0]]))
+
+ assert_array_equal(c.keep_feasible, [True, False])
+
+ # Test 4: interval constraint.
+ user_constraint = Bounds([-1, -np.inf, 2, 3], [1, np.inf, 10, 3],
+ [False, True, True, True])
+ x0 = np.array([0, 10, 8, 5])
+ prepared_constraint = PreparedConstraint(user_constraint, x0, False)
+ c = CanonicalConstraint.from_PreparedConstraint(prepared_constraint)
+
+ assert_equal(c.n_eq, 1)
+ assert_equal(c.n_ineq, 4)
+
+ c_eq, c_ineq = c.fun(x0)
+ assert_array_equal(c_eq, [2])
+ assert_array_equal(c_ineq, [-1, -2, -1, -6])
+
+ J_eq, J_ineq = c.jac(x0)
+ assert_array_equal(J_eq, [[0, 0, 0, 1]])
+ assert_array_equal(J_ineq, [[1, 0, 0, 0],
+ [0, 0, 1, 0],
+ [-1, 0, 0, 0],
+ [0, 0, -1, 0]])
+
+ assert_array_equal(c.keep_feasible, [False, True, False, True])
+
+
+def test_nonlinear_constraint():
+ n = 3
+ m = 5
+ rng = np.random.RandomState(0)
+ x0 = rng.rand(n)
+
+ fun, jac, hess = create_quadratic_function(n, m, rng)
+ f = fun(x0)
+ J = jac(x0)
+
+ lb = [-10, 3, -np.inf, -np.inf, -5]
+ ub = [10, 3, np.inf, 3, np.inf]
+ user_constraint = NonlinearConstraint(
+ fun, lb, ub, jac, hess, [True, False, False, True, False])
+
+ for sparse_jacobian in [False, True]:
+ prepared_constraint = PreparedConstraint(user_constraint, x0,
+ sparse_jacobian)
+ c = CanonicalConstraint.from_PreparedConstraint(prepared_constraint)
+
+ assert_array_equal(c.n_eq, 1)
+ assert_array_equal(c.n_ineq, 4)
+
+ c_eq, c_ineq = c.fun(x0)
+ assert_array_equal(c_eq, [f[1] - lb[1]])
+ assert_array_equal(c_ineq, [f[3] - ub[3], lb[4] - f[4],
+ f[0] - ub[0], lb[0] - f[0]])
+
+ J_eq, J_ineq = c.jac(x0)
+ if sparse_jacobian:
+ J_eq = J_eq.toarray()
+ J_ineq = J_ineq.toarray()
+
+ assert_array_equal(J_eq, J[1, None])
+ assert_array_equal(J_ineq, np.vstack((J[3], -J[4], J[0], -J[0])))
+
+ v_eq = rng.rand(c.n_eq)
+ v_ineq = rng.rand(c.n_ineq)
+ v = np.zeros(m)
+ v[1] = v_eq[0]
+ v[3] = v_ineq[0]
+ v[4] = -v_ineq[1]
+ v[0] = v_ineq[2] - v_ineq[3]
+ assert_array_equal(c.hess(x0, v_eq, v_ineq), hess(x0, v))
+
+ assert_array_equal(c.keep_feasible, [True, False, True, True])
+
+
+def test_concatenation():
+ rng = np.random.RandomState(0)
+ n = 4
+ x0 = rng.rand(n)
+
+ f1 = x0
+ J1 = np.eye(n)
+ lb1 = [-1, -np.inf, -2, 3]
+ ub1 = [1, np.inf, np.inf, 3]
+ bounds = Bounds(lb1, ub1, [False, False, True, False])
+
+ fun, jac, hess = create_quadratic_function(n, 5, rng)
+ f2 = fun(x0)
+ J2 = jac(x0)
+ lb2 = [-10, 3, -np.inf, -np.inf, -5]
+ ub2 = [10, 3, np.inf, 5, np.inf]
+ nonlinear = NonlinearConstraint(
+ fun, lb2, ub2, jac, hess, [True, False, False, True, False])
+
+ for sparse_jacobian in [False, True]:
+ bounds_prepared = PreparedConstraint(bounds, x0, sparse_jacobian)
+ nonlinear_prepared = PreparedConstraint(nonlinear, x0, sparse_jacobian)
+
+ c1 = CanonicalConstraint.from_PreparedConstraint(bounds_prepared)
+ c2 = CanonicalConstraint.from_PreparedConstraint(nonlinear_prepared)
+ c = CanonicalConstraint.concatenate([c1, c2], sparse_jacobian)
+
+ assert_equal(c.n_eq, 2)
+ assert_equal(c.n_ineq, 7)
+
+ c_eq, c_ineq = c.fun(x0)
+ assert_array_equal(c_eq, [f1[3] - lb1[3], f2[1] - lb2[1]])
+ assert_array_equal(c_ineq, [lb1[2] - f1[2], f1[0] - ub1[0],
+ lb1[0] - f1[0], f2[3] - ub2[3],
+ lb2[4] - f2[4], f2[0] - ub2[0],
+ lb2[0] - f2[0]])
+
+ J_eq, J_ineq = c.jac(x0)
+ if sparse_jacobian:
+ J_eq = J_eq.toarray()
+ J_ineq = J_ineq.toarray()
+
+ assert_array_equal(J_eq, np.vstack((J1[3], J2[1])))
+ assert_array_equal(J_ineq, np.vstack((-J1[2], J1[0], -J1[0], J2[3],
+ -J2[4], J2[0], -J2[0])))
+
+ v_eq = rng.rand(c.n_eq)
+ v_ineq = rng.rand(c.n_ineq)
+ v = np.zeros(5)
+ v[1] = v_eq[1]
+ v[3] = v_ineq[3]
+ v[4] = -v_ineq[4]
+ v[0] = v_ineq[5] - v_ineq[6]
+ H = c.hess(x0, v_eq, v_ineq).dot(np.eye(n))
+ assert_array_equal(H, hess(x0, v))
+
+ assert_array_equal(c.keep_feasible,
+ [True, False, False, True, False, True, True])
+
+
+def test_empty():
+ x = np.array([1, 2, 3])
+ c = CanonicalConstraint.empty(3)
+ assert_equal(c.n_eq, 0)
+ assert_equal(c.n_ineq, 0)
+
+ c_eq, c_ineq = c.fun(x)
+ assert_array_equal(c_eq, [])
+ assert_array_equal(c_ineq, [])
+
+ J_eq, J_ineq = c.jac(x)
+ assert_array_equal(J_eq, np.empty((0, 3)))
+ assert_array_equal(J_ineq, np.empty((0, 3)))
+
+ H = c.hess(x, None, None).toarray()
+ assert_array_equal(H, np.zeros((3, 3)))
+
+
+def test_initial_constraints_as_canonical():
+ # rng is only used to generate the coefficients of the quadratic
+ # function that is used by the nonlinear constraint.
+ rng = np.random.RandomState(0)
+
+ x0 = np.array([0.5, 0.4, 0.3, 0.2])
+ n = len(x0)
+
+ lb1 = [-1, -np.inf, -2, 3]
+ ub1 = [1, np.inf, np.inf, 3]
+ bounds = Bounds(lb1, ub1, [False, False, True, False])
+
+ fun, jac, hess = create_quadratic_function(n, 5, rng)
+ lb2 = [-10, 3, -np.inf, -np.inf, -5]
+ ub2 = [10, 3, np.inf, 5, np.inf]
+ nonlinear = NonlinearConstraint(
+ fun, lb2, ub2, jac, hess, [True, False, False, True, False])
+
+ for sparse_jacobian in [False, True]:
+ bounds_prepared = PreparedConstraint(bounds, x0, sparse_jacobian)
+ nonlinear_prepared = PreparedConstraint(nonlinear, x0, sparse_jacobian)
+
+ f1 = bounds_prepared.fun.f
+ J1 = bounds_prepared.fun.J
+ f2 = nonlinear_prepared.fun.f
+ J2 = nonlinear_prepared.fun.J
+
+ c_eq, c_ineq, J_eq, J_ineq = initial_constraints_as_canonical(
+ n, [bounds_prepared, nonlinear_prepared], sparse_jacobian)
+
+ assert_array_equal(c_eq, [f1[3] - lb1[3], f2[1] - lb2[1]])
+ assert_array_equal(c_ineq, [lb1[2] - f1[2], f1[0] - ub1[0],
+ lb1[0] - f1[0], f2[3] - ub2[3],
+ lb2[4] - f2[4], f2[0] - ub2[0],
+ lb2[0] - f2[0]])
+
+ if sparse_jacobian:
+ J1 = J1.toarray()
+ J2 = J2.toarray()
+ J_eq = J_eq.toarray()
+ J_ineq = J_ineq.toarray()
+
+ assert_array_equal(J_eq, np.vstack((J1[3], J2[1])))
+ assert_array_equal(J_ineq, np.vstack((-J1[2], J1[0], -J1[0], J2[3],
+ -J2[4], J2[0], -J2[0])))
+
+
+def test_initial_constraints_as_canonical_empty():
+ n = 3
+ for sparse_jacobian in [False, True]:
+ c_eq, c_ineq, J_eq, J_ineq = initial_constraints_as_canonical(
+ n, [], sparse_jacobian)
+
+ assert_array_equal(c_eq, [])
+ assert_array_equal(c_ineq, [])
+
+ if sparse_jacobian:
+ J_eq = J_eq.toarray()
+ J_ineq = J_ineq.toarray()
+
+ assert_array_equal(J_eq, np.empty((0, n)))
+ assert_array_equal(J_ineq, np.empty((0, n)))
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/test_projections.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/test_projections.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ff3c39d649d0ac663d9b71bb906f1daac021118
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/test_projections.py
@@ -0,0 +1,214 @@
+import numpy as np
+import scipy.linalg
+from scipy.sparse import csc_matrix
+from scipy.optimize._trustregion_constr.projections \
+ import projections, orthogonality
+from numpy.testing import (TestCase, assert_array_almost_equal,
+ assert_equal, assert_allclose)
+
+try:
+ from sksparse.cholmod import cholesky_AAt # noqa: F401
+ sksparse_available = True
+ available_sparse_methods = ("NormalEquation", "AugmentedSystem")
+except ImportError:
+ sksparse_available = False
+ available_sparse_methods = ("AugmentedSystem",)
+available_dense_methods = ('QRFactorization', 'SVDFactorization')
+
+
+class TestProjections(TestCase):
+
+ def test_nullspace_and_least_squares_sparse(self):
+ A_dense = np.array([[1, 2, 3, 4, 0, 5, 0, 7],
+ [0, 8, 7, 0, 1, 5, 9, 0],
+ [1, 0, 0, 0, 0, 1, 2, 3]])
+ At_dense = A_dense.T
+ A = csc_matrix(A_dense)
+ test_points = ([1, 2, 3, 4, 5, 6, 7, 8],
+ [1, 10, 3, 0, 1, 6, 7, 8],
+ [1.12, 10, 0, 0, 100000, 6, 0.7, 8])
+
+ for method in available_sparse_methods:
+ Z, LS, _ = projections(A, method)
+ for z in test_points:
+ # Test if x is in the null_space
+ x = Z.matvec(z)
+ assert_array_almost_equal(A.dot(x), 0)
+ # Test orthogonality
+ assert_array_almost_equal(orthogonality(A, x), 0)
+ # Test if x is the least square solution
+ x = LS.matvec(z)
+ x2 = scipy.linalg.lstsq(At_dense, z)[0]
+ assert_array_almost_equal(x, x2)
+
+ def test_iterative_refinements_sparse(self):
+ A_dense = np.array([[1, 2, 3, 4, 0, 5, 0, 7],
+ [0, 8, 7, 0, 1, 5, 9, 0],
+ [1, 0, 0, 0, 0, 1, 2, 3]])
+ A = csc_matrix(A_dense)
+ test_points = ([1, 2, 3, 4, 5, 6, 7, 8],
+ [1, 10, 3, 0, 1, 6, 7, 8],
+ [1.12, 10, 0, 0, 100000, 6, 0.7, 8],
+ [1, 0, 0, 0, 0, 1, 2, 3+1e-10])
+
+ for method in available_sparse_methods:
+ Z, LS, _ = projections(A, method, orth_tol=1e-18, max_refin=100)
+ for z in test_points:
+ # Test if x is in the null_space
+ x = Z.matvec(z)
+ atol = 1e-13 * abs(x).max()
+ assert_allclose(A.dot(x), 0, atol=atol)
+ # Test orthogonality
+ assert_allclose(orthogonality(A, x), 0, atol=1e-13)
+
+ def test_rowspace_sparse(self):
+ A_dense = np.array([[1, 2, 3, 4, 0, 5, 0, 7],
+ [0, 8, 7, 0, 1, 5, 9, 0],
+ [1, 0, 0, 0, 0, 1, 2, 3]])
+ A = csc_matrix(A_dense)
+ test_points = ([1, 2, 3],
+ [1, 10, 3],
+ [1.12, 10, 0])
+
+ for method in available_sparse_methods:
+ _, _, Y = projections(A, method)
+ for z in test_points:
+ # Test if x is solution of A x = z
+ x = Y.matvec(z)
+ assert_array_almost_equal(A.dot(x), z)
+ # Test if x is in the return row space of A
+ A_ext = np.vstack((A_dense, x))
+ assert_equal(np.linalg.matrix_rank(A_dense),
+ np.linalg.matrix_rank(A_ext))
+
+ def test_nullspace_and_least_squares_dense(self):
+ A = np.array([[1, 2, 3, 4, 0, 5, 0, 7],
+ [0, 8, 7, 0, 1, 5, 9, 0],
+ [1, 0, 0, 0, 0, 1, 2, 3]])
+ At = A.T
+ test_points = ([1, 2, 3, 4, 5, 6, 7, 8],
+ [1, 10, 3, 0, 1, 6, 7, 8],
+ [1.12, 10, 0, 0, 100000, 6, 0.7, 8])
+
+ for method in available_dense_methods:
+ Z, LS, _ = projections(A, method)
+ for z in test_points:
+ # Test if x is in the null_space
+ x = Z.matvec(z)
+ assert_array_almost_equal(A.dot(x), 0)
+ # Test orthogonality
+ assert_array_almost_equal(orthogonality(A, x), 0)
+ # Test if x is the least square solution
+ x = LS.matvec(z)
+ x2 = scipy.linalg.lstsq(At, z)[0]
+ assert_array_almost_equal(x, x2)
+
+ def test_compare_dense_and_sparse(self):
+ D = np.diag(range(1, 101))
+ A = np.hstack([D, D, D, D])
+ A_sparse = csc_matrix(A)
+ np.random.seed(0)
+
+ Z, LS, Y = projections(A)
+ Z_sparse, LS_sparse, Y_sparse = projections(A_sparse)
+ for k in range(20):
+ z = np.random.normal(size=(400,))
+ assert_array_almost_equal(Z.dot(z), Z_sparse.dot(z))
+ assert_array_almost_equal(LS.dot(z), LS_sparse.dot(z))
+ x = np.random.normal(size=(100,))
+ assert_array_almost_equal(Y.dot(x), Y_sparse.dot(x))
+
+ def test_compare_dense_and_sparse2(self):
+ D1 = np.diag([-1.7, 1, 0.5])
+ D2 = np.diag([1, -0.6, -0.3])
+ D3 = np.diag([-0.3, -1.5, 2])
+ A = np.hstack([D1, D2, D3])
+ A_sparse = csc_matrix(A)
+ np.random.seed(0)
+
+ Z, LS, Y = projections(A)
+ Z_sparse, LS_sparse, Y_sparse = projections(A_sparse)
+ for k in range(1):
+ z = np.random.normal(size=(9,))
+ assert_array_almost_equal(Z.dot(z), Z_sparse.dot(z))
+ assert_array_almost_equal(LS.dot(z), LS_sparse.dot(z))
+ x = np.random.normal(size=(3,))
+ assert_array_almost_equal(Y.dot(x), Y_sparse.dot(x))
+
+ def test_iterative_refinements_dense(self):
+ A = np.array([[1, 2, 3, 4, 0, 5, 0, 7],
+ [0, 8, 7, 0, 1, 5, 9, 0],
+ [1, 0, 0, 0, 0, 1, 2, 3]])
+ test_points = ([1, 2, 3, 4, 5, 6, 7, 8],
+ [1, 10, 3, 0, 1, 6, 7, 8],
+ [1, 0, 0, 0, 0, 1, 2, 3+1e-10])
+
+ for method in available_dense_methods:
+ Z, LS, _ = projections(A, method, orth_tol=1e-18, max_refin=10)
+ for z in test_points:
+ # Test if x is in the null_space
+ x = Z.matvec(z)
+ assert_allclose(A.dot(x), 0, rtol=0, atol=2.5e-14)
+ # Test orthogonality
+ assert_allclose(orthogonality(A, x), 0, rtol=0, atol=5e-16)
+
+ def test_rowspace_dense(self):
+ A = np.array([[1, 2, 3, 4, 0, 5, 0, 7],
+ [0, 8, 7, 0, 1, 5, 9, 0],
+ [1, 0, 0, 0, 0, 1, 2, 3]])
+ test_points = ([1, 2, 3],
+ [1, 10, 3],
+ [1.12, 10, 0])
+
+ for method in available_dense_methods:
+ _, _, Y = projections(A, method)
+ for z in test_points:
+ # Test if x is solution of A x = z
+ x = Y.matvec(z)
+ assert_array_almost_equal(A.dot(x), z)
+ # Test if x is in the return row space of A
+ A_ext = np.vstack((A, x))
+ assert_equal(np.linalg.matrix_rank(A),
+ np.linalg.matrix_rank(A_ext))
+
+
+class TestOrthogonality(TestCase):
+
+ def test_dense_matrix(self):
+ A = np.array([[1, 2, 3, 4, 0, 5, 0, 7],
+ [0, 8, 7, 0, 1, 5, 9, 0],
+ [1, 0, 0, 0, 0, 1, 2, 3]])
+ test_vectors = ([-1.98931144, -1.56363389,
+ -0.84115584, 2.2864762,
+ 5.599141, 0.09286976,
+ 1.37040802, -0.28145812],
+ [697.92794044, -4091.65114008,
+ -3327.42316335, 836.86906951,
+ 99434.98929065, -1285.37653682,
+ -4109.21503806, 2935.29289083])
+ test_expected_orth = (0, 0)
+
+ for i in range(len(test_vectors)):
+ x = test_vectors[i]
+ orth = test_expected_orth[i]
+ assert_array_almost_equal(orthogonality(A, x), orth)
+
+ def test_sparse_matrix(self):
+ A = np.array([[1, 2, 3, 4, 0, 5, 0, 7],
+ [0, 8, 7, 0, 1, 5, 9, 0],
+ [1, 0, 0, 0, 0, 1, 2, 3]])
+ A = csc_matrix(A)
+ test_vectors = ([-1.98931144, -1.56363389,
+ -0.84115584, 2.2864762,
+ 5.599141, 0.09286976,
+ 1.37040802, -0.28145812],
+ [697.92794044, -4091.65114008,
+ -3327.42316335, 836.86906951,
+ 99434.98929065, -1285.37653682,
+ -4109.21503806, 2935.29289083])
+ test_expected_orth = (0, 0)
+
+ for i in range(len(test_vectors)):
+ x = test_vectors[i]
+ orth = test_expected_orth[i]
+ assert_array_almost_equal(orthogonality(A, x), orth)
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/test_qp_subproblem.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/test_qp_subproblem.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0235caace6c19563efc31fdf4b8e41d9d81819b
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/test_qp_subproblem.py
@@ -0,0 +1,645 @@
+import numpy as np
+from scipy.sparse import csc_matrix
+from scipy.optimize._trustregion_constr.qp_subproblem \
+ import (eqp_kktfact,
+ projected_cg,
+ box_intersections,
+ sphere_intersections,
+ box_sphere_intersections,
+ modified_dogleg)
+from scipy.optimize._trustregion_constr.projections \
+ import projections
+from numpy.testing import TestCase, assert_array_almost_equal, assert_equal
+import pytest
+
+
+class TestEQPDirectFactorization(TestCase):
+
+ # From Example 16.2 Nocedal/Wright "Numerical
+ # Optimization" p.452.
+ def test_nocedal_example(self):
+ H = csc_matrix([[6, 2, 1],
+ [2, 5, 2],
+ [1, 2, 4]])
+ A = csc_matrix([[1, 0, 1],
+ [0, 1, 1]])
+ c = np.array([-8, -3, -3])
+ b = -np.array([3, 0])
+ x, lagrange_multipliers = eqp_kktfact(H, c, A, b)
+ assert_array_almost_equal(x, [2, -1, 1])
+ assert_array_almost_equal(lagrange_multipliers, [3, -2])
+
+
+class TestSphericalBoundariesIntersections(TestCase):
+
+ def test_2d_sphere_constraints(self):
+ # Interior inicial point
+ ta, tb, intersect = sphere_intersections([0, 0],
+ [1, 0], 0.5)
+ assert_array_almost_equal([ta, tb], [0, 0.5])
+ assert_equal(intersect, True)
+
+ # No intersection between line and circle
+ ta, tb, intersect = sphere_intersections([2, 0],
+ [0, 1], 1)
+ assert_equal(intersect, False)
+
+ # Outside initial point pointing toward outside the circle
+ ta, tb, intersect = sphere_intersections([2, 0],
+ [1, 0], 1)
+ assert_equal(intersect, False)
+
+ # Outside initial point pointing toward inside the circle
+ ta, tb, intersect = sphere_intersections([2, 0],
+ [-1, 0], 1.5)
+ assert_array_almost_equal([ta, tb], [0.5, 1])
+ assert_equal(intersect, True)
+
+ # Initial point on the boundary
+ ta, tb, intersect = sphere_intersections([2, 0],
+ [1, 0], 2)
+ assert_array_almost_equal([ta, tb], [0, 0])
+ assert_equal(intersect, True)
+
+ def test_2d_sphere_constraints_line_intersections(self):
+ # Interior initial point
+ ta, tb, intersect = sphere_intersections([0, 0],
+ [1, 0], 0.5,
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [-0.5, 0.5])
+ assert_equal(intersect, True)
+
+ # No intersection between line and circle
+ ta, tb, intersect = sphere_intersections([2, 0],
+ [0, 1], 1,
+ entire_line=True)
+ assert_equal(intersect, False)
+
+ # Outside initial point pointing toward outside the circle
+ ta, tb, intersect = sphere_intersections([2, 0],
+ [1, 0], 1,
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [-3, -1])
+ assert_equal(intersect, True)
+
+ # Outside initial point pointing toward inside the circle
+ ta, tb, intersect = sphere_intersections([2, 0],
+ [-1, 0], 1.5,
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [0.5, 3.5])
+ assert_equal(intersect, True)
+
+ # Initial point on the boundary
+ ta, tb, intersect = sphere_intersections([2, 0],
+ [1, 0], 2,
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [-4, 0])
+ assert_equal(intersect, True)
+
+
+class TestBoxBoundariesIntersections(TestCase):
+
+ def test_2d_box_constraints(self):
+ # Box constraint in the direction of vector d
+ ta, tb, intersect = box_intersections([2, 0], [0, 2],
+ [1, 1], [3, 3])
+ assert_array_almost_equal([ta, tb], [0.5, 1])
+ assert_equal(intersect, True)
+
+ # Negative direction
+ ta, tb, intersect = box_intersections([2, 0], [0, 2],
+ [1, -3], [3, -1])
+ assert_equal(intersect, False)
+
+ # Some constraints are absent (set to +/- inf)
+ ta, tb, intersect = box_intersections([2, 0], [0, 2],
+ [-np.inf, 1],
+ [np.inf, np.inf])
+ assert_array_almost_equal([ta, tb], [0.5, 1])
+ assert_equal(intersect, True)
+
+ # Intersect on the face of the box
+ ta, tb, intersect = box_intersections([1, 0], [0, 1],
+ [1, 1], [3, 3])
+ assert_array_almost_equal([ta, tb], [1, 1])
+ assert_equal(intersect, True)
+
+ # Interior initial point
+ ta, tb, intersect = box_intersections([0, 0], [4, 4],
+ [-2, -3], [3, 2])
+ assert_array_almost_equal([ta, tb], [0, 0.5])
+ assert_equal(intersect, True)
+
+ # No intersection between line and box constraints
+ ta, tb, intersect = box_intersections([2, 0], [0, 2],
+ [-3, -3], [-1, -1])
+ assert_equal(intersect, False)
+ ta, tb, intersect = box_intersections([2, 0], [0, 2],
+ [-3, 3], [-1, 1])
+ assert_equal(intersect, False)
+ ta, tb, intersect = box_intersections([2, 0], [0, 2],
+ [-3, -np.inf],
+ [-1, np.inf])
+ assert_equal(intersect, False)
+ ta, tb, intersect = box_intersections([0, 0], [1, 100],
+ [1, 1], [3, 3])
+ assert_equal(intersect, False)
+ ta, tb, intersect = box_intersections([0.99, 0], [0, 2],
+ [1, 1], [3, 3])
+ assert_equal(intersect, False)
+
+ # Initial point on the boundary
+ ta, tb, intersect = box_intersections([2, 2], [0, 1],
+ [-2, -2], [2, 2])
+ assert_array_almost_equal([ta, tb], [0, 0])
+ assert_equal(intersect, True)
+
+ def test_2d_box_constraints_entire_line(self):
+ # Box constraint in the direction of vector d
+ ta, tb, intersect = box_intersections([2, 0], [0, 2],
+ [1, 1], [3, 3],
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [0.5, 1.5])
+ assert_equal(intersect, True)
+
+ # Negative direction
+ ta, tb, intersect = box_intersections([2, 0], [0, 2],
+ [1, -3], [3, -1],
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [-1.5, -0.5])
+ assert_equal(intersect, True)
+
+ # Some constraints are absent (set to +/- inf)
+ ta, tb, intersect = box_intersections([2, 0], [0, 2],
+ [-np.inf, 1],
+ [np.inf, np.inf],
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [0.5, np.inf])
+ assert_equal(intersect, True)
+
+ # Intersect on the face of the box
+ ta, tb, intersect = box_intersections([1, 0], [0, 1],
+ [1, 1], [3, 3],
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [1, 3])
+ assert_equal(intersect, True)
+
+ # Interior initial pointoint
+ ta, tb, intersect = box_intersections([0, 0], [4, 4],
+ [-2, -3], [3, 2],
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [-0.5, 0.5])
+ assert_equal(intersect, True)
+
+ # No intersection between line and box constraints
+ ta, tb, intersect = box_intersections([2, 0], [0, 2],
+ [-3, -3], [-1, -1],
+ entire_line=True)
+ assert_equal(intersect, False)
+ ta, tb, intersect = box_intersections([2, 0], [0, 2],
+ [-3, 3], [-1, 1],
+ entire_line=True)
+ assert_equal(intersect, False)
+ ta, tb, intersect = box_intersections([2, 0], [0, 2],
+ [-3, -np.inf],
+ [-1, np.inf],
+ entire_line=True)
+ assert_equal(intersect, False)
+ ta, tb, intersect = box_intersections([0, 0], [1, 100],
+ [1, 1], [3, 3],
+ entire_line=True)
+ assert_equal(intersect, False)
+ ta, tb, intersect = box_intersections([0.99, 0], [0, 2],
+ [1, 1], [3, 3],
+ entire_line=True)
+ assert_equal(intersect, False)
+
+ # Initial point on the boundary
+ ta, tb, intersect = box_intersections([2, 2], [0, 1],
+ [-2, -2], [2, 2],
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [-4, 0])
+ assert_equal(intersect, True)
+
+ def test_3d_box_constraints(self):
+ # Simple case
+ ta, tb, intersect = box_intersections([1, 1, 0], [0, 0, 1],
+ [1, 1, 1], [3, 3, 3])
+ assert_array_almost_equal([ta, tb], [1, 1])
+ assert_equal(intersect, True)
+
+ # Negative direction
+ ta, tb, intersect = box_intersections([1, 1, 0], [0, 0, -1],
+ [1, 1, 1], [3, 3, 3])
+ assert_equal(intersect, False)
+
+ # Interior point
+ ta, tb, intersect = box_intersections([2, 2, 2], [0, -1, 1],
+ [1, 1, 1], [3, 3, 3])
+ assert_array_almost_equal([ta, tb], [0, 1])
+ assert_equal(intersect, True)
+
+ def test_3d_box_constraints_entire_line(self):
+ # Simple case
+ ta, tb, intersect = box_intersections([1, 1, 0], [0, 0, 1],
+ [1, 1, 1], [3, 3, 3],
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [1, 3])
+ assert_equal(intersect, True)
+
+ # Negative direction
+ ta, tb, intersect = box_intersections([1, 1, 0], [0, 0, -1],
+ [1, 1, 1], [3, 3, 3],
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [-3, -1])
+ assert_equal(intersect, True)
+
+ # Interior point
+ ta, tb, intersect = box_intersections([2, 2, 2], [0, -1, 1],
+ [1, 1, 1], [3, 3, 3],
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [-1, 1])
+ assert_equal(intersect, True)
+
+
+class TestBoxSphereBoundariesIntersections(TestCase):
+
+ def test_2d_box_constraints(self):
+ # Both constraints are active
+ ta, tb, intersect = box_sphere_intersections([1, 1], [-2, 2],
+ [-1, -2], [1, 2], 2,
+ entire_line=False)
+ assert_array_almost_equal([ta, tb], [0, 0.5])
+ assert_equal(intersect, True)
+
+ # None of the constraints are active
+ ta, tb, intersect = box_sphere_intersections([1, 1], [-1, 1],
+ [-1, -3], [1, 3], 10,
+ entire_line=False)
+ assert_array_almost_equal([ta, tb], [0, 1])
+ assert_equal(intersect, True)
+
+ # Box constraints are active
+ ta, tb, intersect = box_sphere_intersections([1, 1], [-4, 4],
+ [-1, -3], [1, 3], 10,
+ entire_line=False)
+ assert_array_almost_equal([ta, tb], [0, 0.5])
+ assert_equal(intersect, True)
+
+ # Spherical constraints are active
+ ta, tb, intersect = box_sphere_intersections([1, 1], [-4, 4],
+ [-1, -3], [1, 3], 2,
+ entire_line=False)
+ assert_array_almost_equal([ta, tb], [0, 0.25])
+ assert_equal(intersect, True)
+
+ # Infeasible problems
+ ta, tb, intersect = box_sphere_intersections([2, 2], [-4, 4],
+ [-1, -3], [1, 3], 2,
+ entire_line=False)
+ assert_equal(intersect, False)
+ ta, tb, intersect = box_sphere_intersections([1, 1], [-4, 4],
+ [2, 4], [2, 4], 2,
+ entire_line=False)
+ assert_equal(intersect, False)
+
+ def test_2d_box_constraints_entire_line(self):
+ # Both constraints are active
+ ta, tb, intersect = box_sphere_intersections([1, 1], [-2, 2],
+ [-1, -2], [1, 2], 2,
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [0, 0.5])
+ assert_equal(intersect, True)
+
+ # None of the constraints are active
+ ta, tb, intersect = box_sphere_intersections([1, 1], [-1, 1],
+ [-1, -3], [1, 3], 10,
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [0, 2])
+ assert_equal(intersect, True)
+
+ # Box constraints are active
+ ta, tb, intersect = box_sphere_intersections([1, 1], [-4, 4],
+ [-1, -3], [1, 3], 10,
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [0, 0.5])
+ assert_equal(intersect, True)
+
+ # Spherical constraints are active
+ ta, tb, intersect = box_sphere_intersections([1, 1], [-4, 4],
+ [-1, -3], [1, 3], 2,
+ entire_line=True)
+ assert_array_almost_equal([ta, tb], [0, 0.25])
+ assert_equal(intersect, True)
+
+ # Infeasible problems
+ ta, tb, intersect = box_sphere_intersections([2, 2], [-4, 4],
+ [-1, -3], [1, 3], 2,
+ entire_line=True)
+ assert_equal(intersect, False)
+ ta, tb, intersect = box_sphere_intersections([1, 1], [-4, 4],
+ [2, 4], [2, 4], 2,
+ entire_line=True)
+ assert_equal(intersect, False)
+
+
+class TestModifiedDogleg(TestCase):
+
+ def test_cauchypoint_equalsto_newtonpoint(self):
+ A = np.array([[1, 8]])
+ b = np.array([-16])
+ _, _, Y = projections(A)
+ newton_point = np.array([0.24615385, 1.96923077])
+
+ # Newton point inside boundaries
+ x = modified_dogleg(A, Y, b, 2, [-np.inf, -np.inf], [np.inf, np.inf])
+ assert_array_almost_equal(x, newton_point)
+
+ # Spherical constraint active
+ x = modified_dogleg(A, Y, b, 1, [-np.inf, -np.inf], [np.inf, np.inf])
+ assert_array_almost_equal(x, newton_point/np.linalg.norm(newton_point))
+
+ # Box constraints active
+ x = modified_dogleg(A, Y, b, 2, [-np.inf, -np.inf], [0.1, np.inf])
+ assert_array_almost_equal(x, (newton_point/newton_point[0]) * 0.1)
+
+ def test_3d_example(self):
+ A = np.array([[1, 8, 1],
+ [4, 2, 2]])
+ b = np.array([-16, 2])
+ Z, LS, Y = projections(A)
+
+ newton_point = np.array([-1.37090909, 2.23272727, -0.49090909])
+ cauchy_point = np.array([0.11165723, 1.73068711, 0.16748585])
+ origin = np.zeros_like(newton_point)
+
+ # newton_point inside boundaries
+ x = modified_dogleg(A, Y, b, 3, [-np.inf, -np.inf, -np.inf],
+ [np.inf, np.inf, np.inf])
+ assert_array_almost_equal(x, newton_point)
+
+ # line between cauchy_point and newton_point contains best point
+ # (spherical constraint is active).
+ x = modified_dogleg(A, Y, b, 2, [-np.inf, -np.inf, -np.inf],
+ [np.inf, np.inf, np.inf])
+ z = cauchy_point
+ d = newton_point-cauchy_point
+ t = ((x-z)/(d))
+ assert_array_almost_equal(t, np.full(3, 0.40807330))
+ assert_array_almost_equal(np.linalg.norm(x), 2)
+
+ # line between cauchy_point and newton_point contains best point
+ # (box constraint is active).
+ x = modified_dogleg(A, Y, b, 5, [-1, -np.inf, -np.inf],
+ [np.inf, np.inf, np.inf])
+ z = cauchy_point
+ d = newton_point-cauchy_point
+ t = ((x-z)/(d))
+ assert_array_almost_equal(t, np.full(3, 0.7498195))
+ assert_array_almost_equal(x[0], -1)
+
+ # line between origin and cauchy_point contains best point
+ # (spherical constraint is active).
+ x = modified_dogleg(A, Y, b, 1, [-np.inf, -np.inf, -np.inf],
+ [np.inf, np.inf, np.inf])
+ z = origin
+ d = cauchy_point
+ t = ((x-z)/(d))
+ assert_array_almost_equal(t, np.full(3, 0.573936265))
+ assert_array_almost_equal(np.linalg.norm(x), 1)
+
+ # line between origin and newton_point contains best point
+ # (box constraint is active).
+ x = modified_dogleg(A, Y, b, 2, [-np.inf, -np.inf, -np.inf],
+ [np.inf, 1, np.inf])
+ z = origin
+ d = newton_point
+ t = ((x-z)/(d))
+ assert_array_almost_equal(t, np.full(3, 0.4478827364))
+ assert_array_almost_equal(x[1], 1)
+
+
+class TestProjectCG(TestCase):
+
+ # From Example 16.2 Nocedal/Wright "Numerical
+ # Optimization" p.452.
+ def test_nocedal_example(self):
+ H = csc_matrix([[6, 2, 1],
+ [2, 5, 2],
+ [1, 2, 4]])
+ A = csc_matrix([[1, 0, 1],
+ [0, 1, 1]])
+ c = np.array([-8, -3, -3])
+ b = -np.array([3, 0])
+ Z, _, Y = projections(A)
+ x, info = projected_cg(H, c, Z, Y, b)
+ assert_equal(info["stop_cond"], 4)
+ assert_equal(info["hits_boundary"], False)
+ assert_array_almost_equal(x, [2, -1, 1])
+
+ def test_compare_with_direct_fact(self):
+ H = csc_matrix([[6, 2, 1, 3],
+ [2, 5, 2, 4],
+ [1, 2, 4, 5],
+ [3, 4, 5, 7]])
+ A = csc_matrix([[1, 0, 1, 0],
+ [0, 1, 1, 1]])
+ c = np.array([-2, -3, -3, 1])
+ b = -np.array([3, 0])
+ Z, _, Y = projections(A)
+ x, info = projected_cg(H, c, Z, Y, b, tol=0)
+ x_kkt, _ = eqp_kktfact(H, c, A, b)
+ assert_equal(info["stop_cond"], 1)
+ assert_equal(info["hits_boundary"], False)
+ assert_array_almost_equal(x, x_kkt)
+
+ def test_trust_region_infeasible(self):
+ H = csc_matrix([[6, 2, 1, 3],
+ [2, 5, 2, 4],
+ [1, 2, 4, 5],
+ [3, 4, 5, 7]])
+ A = csc_matrix([[1, 0, 1, 0],
+ [0, 1, 1, 1]])
+ c = np.array([-2, -3, -3, 1])
+ b = -np.array([3, 0])
+ trust_radius = 1
+ Z, _, Y = projections(A)
+ with pytest.raises(ValueError):
+ projected_cg(H, c, Z, Y, b, trust_radius=trust_radius)
+
+ def test_trust_region_barely_feasible(self):
+ H = csc_matrix([[6, 2, 1, 3],
+ [2, 5, 2, 4],
+ [1, 2, 4, 5],
+ [3, 4, 5, 7]])
+ A = csc_matrix([[1, 0, 1, 0],
+ [0, 1, 1, 1]])
+ c = np.array([-2, -3, -3, 1])
+ b = -np.array([3, 0])
+ trust_radius = 2.32379000772445021283
+ Z, _, Y = projections(A)
+ x, info = projected_cg(H, c, Z, Y, b,
+ tol=0,
+ trust_radius=trust_radius)
+ assert_equal(info["stop_cond"], 2)
+ assert_equal(info["hits_boundary"], True)
+ assert_array_almost_equal(np.linalg.norm(x), trust_radius)
+ assert_array_almost_equal(x, -Y.dot(b))
+
+ def test_hits_boundary(self):
+ H = csc_matrix([[6, 2, 1, 3],
+ [2, 5, 2, 4],
+ [1, 2, 4, 5],
+ [3, 4, 5, 7]])
+ A = csc_matrix([[1, 0, 1, 0],
+ [0, 1, 1, 1]])
+ c = np.array([-2, -3, -3, 1])
+ b = -np.array([3, 0])
+ trust_radius = 3
+ Z, _, Y = projections(A)
+ x, info = projected_cg(H, c, Z, Y, b,
+ tol=0,
+ trust_radius=trust_radius)
+ assert_equal(info["stop_cond"], 2)
+ assert_equal(info["hits_boundary"], True)
+ assert_array_almost_equal(np.linalg.norm(x), trust_radius)
+
+ def test_negative_curvature_unconstrained(self):
+ H = csc_matrix([[1, 2, 1, 3],
+ [2, 0, 2, 4],
+ [1, 2, 0, 2],
+ [3, 4, 2, 0]])
+ A = csc_matrix([[1, 0, 1, 0],
+ [0, 1, 0, 1]])
+ c = np.array([-2, -3, -3, 1])
+ b = -np.array([3, 0])
+ Z, _, Y = projections(A)
+ with pytest.raises(ValueError):
+ projected_cg(H, c, Z, Y, b, tol=0)
+
+ def test_negative_curvature(self):
+ H = csc_matrix([[1, 2, 1, 3],
+ [2, 0, 2, 4],
+ [1, 2, 0, 2],
+ [3, 4, 2, 0]])
+ A = csc_matrix([[1, 0, 1, 0],
+ [0, 1, 0, 1]])
+ c = np.array([-2, -3, -3, 1])
+ b = -np.array([3, 0])
+ Z, _, Y = projections(A)
+ trust_radius = 1000
+ x, info = projected_cg(H, c, Z, Y, b,
+ tol=0,
+ trust_radius=trust_radius)
+ assert_equal(info["stop_cond"], 3)
+ assert_equal(info["hits_boundary"], True)
+ assert_array_almost_equal(np.linalg.norm(x), trust_radius)
+
+ # The box constraints are inactive at the solution but
+ # are active during the iterations.
+ def test_inactive_box_constraints(self):
+ H = csc_matrix([[6, 2, 1, 3],
+ [2, 5, 2, 4],
+ [1, 2, 4, 5],
+ [3, 4, 5, 7]])
+ A = csc_matrix([[1, 0, 1, 0],
+ [0, 1, 1, 1]])
+ c = np.array([-2, -3, -3, 1])
+ b = -np.array([3, 0])
+ Z, _, Y = projections(A)
+ x, info = projected_cg(H, c, Z, Y, b,
+ tol=0,
+ lb=[0.5, -np.inf,
+ -np.inf, -np.inf],
+ return_all=True)
+ x_kkt, _ = eqp_kktfact(H, c, A, b)
+ assert_equal(info["stop_cond"], 1)
+ assert_equal(info["hits_boundary"], False)
+ assert_array_almost_equal(x, x_kkt)
+
+ # The box constraints active and the termination is
+ # by maximum iterations (infeasible interaction).
+ def test_active_box_constraints_maximum_iterations_reached(self):
+ H = csc_matrix([[6, 2, 1, 3],
+ [2, 5, 2, 4],
+ [1, 2, 4, 5],
+ [3, 4, 5, 7]])
+ A = csc_matrix([[1, 0, 1, 0],
+ [0, 1, 1, 1]])
+ c = np.array([-2, -3, -3, 1])
+ b = -np.array([3, 0])
+ Z, _, Y = projections(A)
+ x, info = projected_cg(H, c, Z, Y, b,
+ tol=0,
+ lb=[0.8, -np.inf,
+ -np.inf, -np.inf],
+ return_all=True)
+ assert_equal(info["stop_cond"], 1)
+ assert_equal(info["hits_boundary"], True)
+ assert_array_almost_equal(A.dot(x), -b)
+ assert_array_almost_equal(x[0], 0.8)
+
+ # The box constraints are active and the termination is
+ # because it hits boundary (without infeasible interaction).
+ def test_active_box_constraints_hits_boundaries(self):
+ H = csc_matrix([[6, 2, 1, 3],
+ [2, 5, 2, 4],
+ [1, 2, 4, 5],
+ [3, 4, 5, 7]])
+ A = csc_matrix([[1, 0, 1, 0],
+ [0, 1, 1, 1]])
+ c = np.array([-2, -3, -3, 1])
+ b = -np.array([3, 0])
+ trust_radius = 3
+ Z, _, Y = projections(A)
+ x, info = projected_cg(H, c, Z, Y, b,
+ tol=0,
+ ub=[np.inf, np.inf, 1.6, np.inf],
+ trust_radius=trust_radius,
+ return_all=True)
+ assert_equal(info["stop_cond"], 2)
+ assert_equal(info["hits_boundary"], True)
+ assert_array_almost_equal(x[2], 1.6)
+
+ # The box constraints are active and the termination is
+ # because it hits boundary (infeasible interaction).
+ def test_active_box_constraints_hits_boundaries_infeasible_iter(self):
+ H = csc_matrix([[6, 2, 1, 3],
+ [2, 5, 2, 4],
+ [1, 2, 4, 5],
+ [3, 4, 5, 7]])
+ A = csc_matrix([[1, 0, 1, 0],
+ [0, 1, 1, 1]])
+ c = np.array([-2, -3, -3, 1])
+ b = -np.array([3, 0])
+ trust_radius = 4
+ Z, _, Y = projections(A)
+ x, info = projected_cg(H, c, Z, Y, b,
+ tol=0,
+ ub=[np.inf, 0.1, np.inf, np.inf],
+ trust_radius=trust_radius,
+ return_all=True)
+ assert_equal(info["stop_cond"], 2)
+ assert_equal(info["hits_boundary"], True)
+ assert_array_almost_equal(x[1], 0.1)
+
+ # The box constraints are active and the termination is
+ # because it hits boundary (no infeasible interaction).
+ def test_active_box_constraints_negative_curvature(self):
+ H = csc_matrix([[1, 2, 1, 3],
+ [2, 0, 2, 4],
+ [1, 2, 0, 2],
+ [3, 4, 2, 0]])
+ A = csc_matrix([[1, 0, 1, 0],
+ [0, 1, 0, 1]])
+ c = np.array([-2, -3, -3, 1])
+ b = -np.array([3, 0])
+ Z, _, Y = projections(A)
+ trust_radius = 1000
+ x, info = projected_cg(H, c, Z, Y, b,
+ tol=0,
+ ub=[np.inf, np.inf, 100, np.inf],
+ trust_radius=trust_radius)
+ assert_equal(info["stop_cond"], 3)
+ assert_equal(info["hits_boundary"], True)
+ assert_array_almost_equal(x[2], 100)
diff --git a/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/test_report.py b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/test_report.py
new file mode 100644
index 0000000000000000000000000000000000000000..c82796fea723ab043971564306d4b76bdf9f0380
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/tests/test_report.py
@@ -0,0 +1,34 @@
+import pytest
+import numpy as np
+from scipy.optimize import minimize, Bounds
+
+def test_gh10880():
+ # checks that verbose reporting works with trust-constr for
+ # bound-contrained problems
+ bnds = Bounds(1, 2)
+ opts = {'maxiter': 1000, 'verbose': 2}
+ minimize(lambda x: x**2, x0=2., method='trust-constr',
+ bounds=bnds, options=opts)
+
+ opts = {'maxiter': 1000, 'verbose': 3}
+ minimize(lambda x: x**2, x0=2., method='trust-constr',
+ bounds=bnds, options=opts)
+
+@pytest.mark.xslow
+def test_gh12922():
+ # checks that verbose reporting works with trust-constr for
+ # general constraints
+ def objective(x):
+ return np.array([(np.sum((x+1)**4))])
+
+ cons = {'type': 'ineq', 'fun': lambda x: -x[0]**2}
+ n = 25
+ x0 = np.linspace(-5, 5, n)
+
+ opts = {'maxiter': 1000, 'verbose': 2}
+ minimize(objective, x0=x0, method='trust-constr',
+ constraints=cons, options=opts)
+
+ opts = {'maxiter': 1000, 'verbose': 3}
+ minimize(objective, x0=x0, method='trust-constr',
+ constraints=cons, options=opts)
diff --git a/vllm/lib/python3.10/site-packages/transformers/generation/__pycache__/logits_process.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/generation/__pycache__/logits_process.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cf730d32ec8ccbdb8102faeac6c61a75775afbf1
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/generation/__pycache__/logits_process.cpython-310.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83b349ed862ec45f0013a5aed6f0b165e3f93f9b6ac9d35f1ca94c149e36cc55
+size 121302
diff --git a/vllm/lib/python3.10/site-packages/transformers/generation/__pycache__/tf_utils.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/generation/__pycache__/tf_utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3a35dc810b282cafb27f0deba82f1a5386e222bf
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/generation/__pycache__/tf_utils.cpython-310.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9063b9d40ec0d4ed1c0bbefe449b7c458fb783f45c308f4e60f9b2eb15a5c241
+size 103620
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/bloom/__init__.py b/vllm/lib/python3.10/site-packages/transformers/models/bloom/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..72d1d6e6ca4724235ce46978e5c11e84583d4033
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/bloom/__init__.py
@@ -0,0 +1,29 @@
+# Copyright 2024 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import TYPE_CHECKING
+
+from ...utils import _LazyModule
+from ...utils.import_utils import define_import_structure
+
+
+if TYPE_CHECKING:
+ from .configuration_bloom import *
+ from .modeling_bloom import *
+ from .modeling_flax_bloom import *
+ from .tokenization_bloom_fast import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/bloom/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/bloom/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b68d741b68e16e1b934b7a520531b0a25350081d
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/bloom/__pycache__/__init__.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/bloom/__pycache__/configuration_bloom.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/bloom/__pycache__/configuration_bloom.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..13d4be02cdf7dc31af4bf3af530bbc34ead0e3f4
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/bloom/__pycache__/configuration_bloom.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/bloom/__pycache__/modeling_flax_bloom.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/bloom/__pycache__/modeling_flax_bloom.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1354cc77266698ec4a53b108493f8f37f2764a86
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/bloom/__pycache__/modeling_flax_bloom.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/bloom/__pycache__/tokenization_bloom_fast.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/bloom/__pycache__/tokenization_bloom_fast.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..610bc340969b4a7ced0acf7c2076f53977d9a85f
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/bloom/__pycache__/tokenization_bloom_fast.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/bloom/configuration_bloom.py b/vllm/lib/python3.10/site-packages/transformers/models/bloom/configuration_bloom.py
new file mode 100644
index 0000000000000000000000000000000000000000..ca10c7ce7ed4ef795f8aefad01bcf93bc88099ee
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/bloom/configuration_bloom.py
@@ -0,0 +1,237 @@
+# coding=utf-8
+# Copyright 2022 the Big Science Workshop and HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Bloom configuration"""
+
+from collections import OrderedDict
+from typing import TYPE_CHECKING, Any, List, Mapping, Optional
+
+from packaging import version
+
+
+if TYPE_CHECKING:
+ from ... import PreTrainedTokenizer, TensorType
+
+from ...configuration_utils import PretrainedConfig
+from ...onnx import OnnxConfigWithPast, PatchingSpec
+from ...utils import is_torch_available, logging
+
+
+logger = logging.get_logger(__name__)
+
+
+class BloomConfig(PretrainedConfig):
+ """
+ This is the configuration class to store the configuration of a [`BloomModel`]. It is used to instantiate a Bloom
+ model according to the specified arguments, defining the model architecture. Instantiating a configuration with the
+ defaults will yield a similar configuration to the Bloom architecture
+ [bigscience/bloom](https://huggingface.co/bigscience/bloom).
+
+ Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+ documentation from [`PretrainedConfig`] for more information.
+
+
+ Args:
+ vocab_size (`int`, *optional*, defaults to 250880):
+ Vocabulary size of the Bloom model. Defines the maximum number of different tokens that can be represented
+ by the `inputs_ids` passed when calling [`BloomModel`]. Check [this
+ discussion](https://huggingface.co/bigscience/bloom/discussions/120#633d28389addb8530b406c2a) on how the
+ `vocab_size` has been defined.
+ hidden_size (`int`, *optional*, defaults to 64):
+ Dimensionality of the embeddings and hidden states.
+ n_layer (`int`, *optional*, defaults to 2):
+ Number of hidden layers in the Transformer encoder.
+ n_head (`int`, *optional*, defaults to 8):
+ Number of attention heads for each attention layer in the Transformer encoder.
+ layer_norm_epsilon (`float`, *optional*, defaults to 1e-5):
+ The epsilon to use in the layer normalization layers.
+ initializer_range (`float`, *optional*, defaults to 0.02):
+ The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+ apply_residual_connection_post_layernorm (`bool`, *optional*, defaults to `False`):
+ If enabled, use the layer norm of the hidden states as the residual in the transformer blocks
+ hidden_dropout (`float`, *optional*, defaults to 0.1):
+ Dropout rate of the dropout function on the bias dropout.
+ attention_dropout (`float`, *optional*, defaults to 0.1):
+ Dropout rate applied to the attention probs
+ use_cache (`bool`, *optional*, defaults to `True`):
+ Whether or not the model should return the last key/values attentions (not used by all models).
+ pretraining_tp (`int`, *optional*, defaults to `1`):
+ Experimental feature. Tensor parallelism rank used during pretraining with Megatron. Please refer to [this
+ document](https://huggingface.co/docs/transformers/parallelism) to understand more about it. This value is
+ necessary to ensure exact reproducibility of the pretraining results. Please refer to [this
+ issue](https://github.com/pytorch/pytorch/issues/76232). Note also that this is enabled only when
+ `slow_but_exact=True`.
+ slow_but_exact (`bool`, *optional*, defaults to `False`):
+ Experimental feature. Whether to use slow but exact implementation of the attention mechanism. While
+ merging the TP rank tensors, due to slicing operations the results may be slightly different between the
+ model trained on Megatron and our model. Please refer to [this
+ issue](https://github.com/pytorch/pytorch/issues/76232). A solution to obtain more accurate results is to
+ enable this feature. Enabling this will hurt the computational time of the inference. Will be probably
+ resolved in the future once the main model has been fine-tuned with TP_rank=1.
+
+ Example:
+
+ ```python
+ >>> from transformers import BloomConfig, BloomModel
+
+ >>> # Initializing a Bloom configuration
+ >>> configuration = BloomConfig()
+
+ >>> # Initializing a model (with random weights) from the configuration
+ >>> model = BloomModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "bloom"
+ keys_to_ignore_at_inference = ["past_key_values"]
+ attribute_map = {
+ "num_hidden_layers": "n_layer",
+ "num_attention_heads": "n_head",
+ }
+
+ def __init__(
+ self,
+ vocab_size=250880,
+ hidden_size=64,
+ n_layer=2,
+ n_head=8,
+ layer_norm_epsilon=1e-5,
+ initializer_range=0.02,
+ use_cache=True,
+ bos_token_id=1,
+ eos_token_id=2,
+ apply_residual_connection_post_layernorm=False,
+ hidden_dropout=0.0,
+ attention_dropout=0.0,
+ pretraining_tp=1, # TP rank used when training with megatron
+ slow_but_exact=False,
+ **kwargs,
+ ):
+ self.vocab_size = vocab_size
+ # Backward compatibility with n_embed kwarg
+ n_embed = kwargs.pop("n_embed", None)
+ self.hidden_size = hidden_size if n_embed is None else n_embed
+ self.n_layer = n_layer
+ self.n_head = n_head
+ self.layer_norm_epsilon = layer_norm_epsilon
+ self.initializer_range = initializer_range
+ self.use_cache = use_cache
+ self.pretraining_tp = pretraining_tp
+ self.apply_residual_connection_post_layernorm = apply_residual_connection_post_layernorm
+ self.hidden_dropout = hidden_dropout
+ self.attention_dropout = attention_dropout
+
+ self.bos_token_id = bos_token_id
+ self.eos_token_id = eos_token_id
+ self.slow_but_exact = slow_but_exact
+
+ super().__init__(bos_token_id=bos_token_id, eos_token_id=eos_token_id, **kwargs)
+
+
+class BloomOnnxConfig(OnnxConfigWithPast):
+ torch_onnx_minimum_version = version.parse("1.12")
+
+ def __init__(
+ self,
+ config: PretrainedConfig,
+ task: str = "default",
+ patching_specs: List[PatchingSpec] = None,
+ use_past: bool = False,
+ ):
+ super().__init__(config, task=task, patching_specs=patching_specs, use_past=use_past)
+ if not getattr(self._config, "pad_token_id", None):
+ # TODO: how to do that better?
+ self._config.pad_token_id = 0
+
+ @property
+ def inputs(self) -> Mapping[str, Mapping[int, str]]:
+ common_inputs = OrderedDict({"input_ids": {0: "batch", 1: "sequence"}})
+ if self.use_past:
+ # BLOOM stores values on dynamic axis 2. For more details see: https://github.com/huggingface/transformers/pull/18344
+ self.fill_with_past_key_values_(common_inputs, direction="inputs", inverted_values_shape=True)
+ common_inputs["attention_mask"] = {0: "batch", 1: "past_sequence + sequence"}
+ else:
+ common_inputs["attention_mask"] = {0: "batch", 1: "sequence"}
+
+ return common_inputs
+
+ @property
+ def num_layers(self) -> int:
+ return self._config.n_layer
+
+ @property
+ def num_attention_heads(self) -> int:
+ return self._config.n_head
+
+ @property
+ def atol_for_validation(self) -> float:
+ return 1e-3
+
+ def generate_dummy_inputs(
+ self,
+ tokenizer: "PreTrainedTokenizer",
+ batch_size: int = -1,
+ seq_length: int = -1,
+ is_pair: bool = False,
+ framework: Optional["TensorType"] = None,
+ ) -> Mapping[str, Any]:
+ common_inputs = super(OnnxConfigWithPast, self).generate_dummy_inputs(
+ tokenizer, batch_size=batch_size, seq_length=seq_length, is_pair=is_pair, framework=framework
+ )
+
+ # We need to order the input in the way they appears in the forward()
+ ordered_inputs = OrderedDict({"input_ids": common_inputs["input_ids"]})
+
+ # Need to add the past_keys
+ if self.use_past:
+ if not is_torch_available():
+ raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed.")
+ else:
+ import torch
+
+ batch, seqlen = common_inputs["input_ids"].shape
+ # Not using the same length for past_key_values
+ past_key_values_length = seqlen + 2
+ head_dim = self._config.hidden_size // self.num_attention_heads
+ past_key_shape = (
+ batch * self.num_attention_heads,
+ head_dim,
+ past_key_values_length,
+ )
+ past_value_shape = (
+ batch * self.num_attention_heads,
+ past_key_values_length,
+ head_dim,
+ )
+ ordered_inputs["past_key_values"] = [
+ (torch.zeros(past_key_shape), torch.zeros(past_value_shape)) for _ in range(self.num_layers)
+ ]
+
+ ordered_inputs["attention_mask"] = common_inputs["attention_mask"]
+ if self.use_past:
+ mask_dtype = ordered_inputs["attention_mask"].dtype
+ ordered_inputs["attention_mask"] = torch.cat(
+ [ordered_inputs["attention_mask"], torch.ones(batch, past_key_values_length, dtype=mask_dtype)], dim=1
+ )
+
+ return ordered_inputs
+
+ @property
+ def default_onnx_opset(self) -> int:
+ return 13
+
+
+__all__ = ["BloomConfig", "BloomOnnxConfig"]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/bloom/modeling_bloom.py b/vllm/lib/python3.10/site-packages/transformers/models/bloom/modeling_bloom.py
new file mode 100644
index 0000000000000000000000000000000000000000..f91cd85779a315f99f6caa5275941509e03192d1
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/bloom/modeling_bloom.py
@@ -0,0 +1,1398 @@
+# coding=utf-8
+# Copyright 2022 HuggingFace Inc. team and BigScience workshop.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""PyTorch BLOOM model."""
+
+import math
+import warnings
+from typing import Optional, Tuple, Union
+
+import torch
+import torch.utils.checkpoint
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, LayerNorm, MSELoss
+from torch.nn import functional as F
+
+from ...cache_utils import Cache, DynamicCache, StaticCache
+from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
+from ...generation import GenerationMixin
+from ...modeling_attn_mask_utils import AttentionMaskConverter
+from ...modeling_outputs import (
+ BaseModelOutputWithPastAndCrossAttentions,
+ CausalLMOutputWithCrossAttentions,
+ QuestionAnsweringModelOutput,
+ SequenceClassifierOutputWithPast,
+ TokenClassifierOutput,
+)
+from ...modeling_utils import PreTrainedModel
+from ...utils import (
+ is_torch_flex_attn_available,
+ logging,
+)
+from .configuration_bloom import BloomConfig
+
+
+if is_torch_flex_attn_available():
+ from torch.nn.attention.flex_attention import BlockMask
+
+ from ...integrations.flex_attention import make_flex_block_causal_mask
+
+
+logger = logging.get_logger(__name__)
+
+_CHECKPOINT_FOR_DOC = "bigscience/bloom-560m"
+_CONFIG_FOR_DOC = "BloomConfig"
+
+
+def build_alibi_tensor(attention_mask: torch.Tensor, num_heads: int, dtype: torch.dtype) -> torch.Tensor:
+ """
+ Link to paper: https://arxiv.org/abs/2108.12409 Alibi tensor is not causal as the original paper mentions, it
+ relies on a translation invariance of softmax for quick implementation: with l being a tensor, and a fixed value
+ `softmax(l+a) = softmax(l)`. Based on
+ https://github.com/ofirpress/attention_with_linear_biases/blob/a35aaca144e0eb6b789dfcb46784c4b8e31b7983/fairseq/models/transformer.py#L742
+ TODO @thomasw21 this doesn't work as nicely due to the masking strategy, and so masking varies slightly.
+
+ Args:
+ Returns tensor shaped (batch_size * num_heads, 1, max_seq_len)
+ attention_mask (`torch.Tensor`):
+ Token-wise attention mask, this should be of shape (batch_size, max_seq_len).
+ num_heads (`int`):
+ number of heads
+ dtype (`torch.dtype`, *optional*, default=`torch.bfloat16`):
+ dtype of the output tensor
+ """
+ batch_size, seq_length = attention_mask.shape
+ closest_power_of_2 = 2 ** math.floor(math.log2(num_heads))
+ base = torch.tensor(
+ 2 ** (-(2 ** -(math.log2(closest_power_of_2) - 3))), device=attention_mask.device, dtype=torch.float32
+ )
+ powers = torch.arange(1, 1 + closest_power_of_2, device=attention_mask.device, dtype=torch.int32)
+ slopes = torch.pow(base, powers)
+
+ if closest_power_of_2 != num_heads:
+ extra_base = torch.tensor(
+ 2 ** (-(2 ** -(math.log2(2 * closest_power_of_2) - 3))), device=attention_mask.device, dtype=torch.float32
+ )
+ num_remaining_heads = min(closest_power_of_2, num_heads - closest_power_of_2)
+ extra_powers = torch.arange(1, 1 + 2 * num_remaining_heads, 2, device=attention_mask.device, dtype=torch.int32)
+ slopes = torch.cat([slopes, torch.pow(extra_base, extra_powers)], dim=0)
+
+ # Note: alibi will added to the attention bias that will be applied to the query, key product of attention
+ # => therefore alibi will have to be of shape (batch_size, num_heads, query_length, key_length)
+ # => here we set (batch_size=1, num_heads=num_heads, query_length=1, key_length=max_length)
+ # => the query_length dimension will then be broadcasted correctly
+ # This is more or less identical to T5's relative position bias:
+ # https://github.com/huggingface/transformers/blob/f681437203baa7671de3174b0fa583c349d9d5e1/src/transformers/models/t5/modeling_t5.py#L527
+ arange_tensor = ((attention_mask.cumsum(dim=-1) - 1) * attention_mask)[:, None, :]
+ alibi = slopes[..., None] * arange_tensor
+ return alibi.reshape(batch_size * num_heads, 1, seq_length).to(dtype)
+
+
+def dropout_add(x: torch.Tensor, residual: torch.Tensor, prob: float, training: bool) -> torch.Tensor:
+ """
+ Dropout add function
+
+ Args:
+ x (`torch.tensor`):
+ input tensor
+ residual (`torch.tensor`):
+ residual tensor
+ prob (`float`):
+ dropout probability
+ training (`bool`):
+ training mode
+ """
+ out = F.dropout(x, p=prob, training=training)
+ out = residual + out
+ return out
+
+
+def bloom_gelu_forward(x: torch.Tensor) -> torch.Tensor:
+ """
+ Custom bias GELU function. Adapted from Megatron-DeepSpeed code. Here we use a simple implementation (inference) to
+ make the model jitable.
+
+ Args:
+ x (`torch.tensor`):
+ input hidden states
+ """
+ return x * 0.5 * (1.0 + torch.tanh(0.79788456 * x * (1 + 0.044715 * x * x)))
+
+
+def bloom_gelu_back(g: torch.Tensor, x: torch.Tensor) -> torch.Tensor:
+ """
+ gradient of tanh approximation of gelu gradient of actual gelu is: 0.5 * (1. + torch.erf(x * 0.70710678)) +
+ 0.3989423 * x * torch.exp(-0.5 * x * x)
+
+ Args:
+ g (`torch.tensor`):
+ gradient output tensor
+ x (`torch.tensor`):
+ input tensor
+ """
+ x = x[0] # x is a tuple of 1 element, needs to unpack it first
+ tanh_out = torch.tanh(0.79788456 * x * (1 + 0.044715 * x * x))
+ # sqrt(2/pi) * 3 * 0.044715 -> 0.1070322243
+ ff = 0.5 * x * ((1 - tanh_out * tanh_out) * (0.79788456 + 0.1070322243 * x * x)) + 0.5 * (1 + tanh_out)
+ return ff * g
+
+
+class GeLUFunction(torch.autograd.Function):
+ @staticmethod
+ def forward(ctx, input: torch.Tensor) -> torch.Tensor:
+ ctx.save_for_backward(input)
+ return bloom_gelu_forward(input)
+
+ @staticmethod
+ def backward(ctx, grad_output: torch.Tensor) -> torch.Tensor:
+ input = ctx.saved_tensors
+ tmp = bloom_gelu_back(grad_output, input)
+ return tmp
+
+
+class BloomGelu(nn.Module):
+ """
+ BloomBiasGelu wrapper function that make use of the simple function on inference mode to make the model
+ torchscriptable and use the autograd function in training mode to get the accurate results of the gradients Partly
+ copied from Megatron-DeepSpeed code and adapted for our needs
+
+ See here why autograd functions are not torchscriptable: https://github.com/pytorch/pytorch/issues/22329
+ """
+
+ def __init__(self):
+ super().__init__()
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ if self.training:
+ return GeLUFunction.apply(x)
+ else:
+ return bloom_gelu_forward(x)
+
+
+class BloomAttention(nn.Module):
+ def __init__(self, config: BloomConfig, layer_idx: Optional[int] = None):
+ super().__init__()
+
+ self.pretraining_tp = config.pretraining_tp
+ self.slow_but_exact = config.slow_but_exact
+
+ self.hidden_size = config.hidden_size
+ self.num_heads = config.n_head
+ self.head_dim = self.hidden_size // self.num_heads
+ self.split_size = self.hidden_size
+ self.hidden_dropout = config.hidden_dropout
+
+ if self.head_dim * self.num_heads != self.hidden_size:
+ raise ValueError(
+ f"`hidden_size` must be divisible by num_heads (got `hidden_size`: {self.hidden_size} and `num_heads`:"
+ f" {self.num_heads})."
+ )
+
+ # Layer-wise attention scaling
+ self.inv_norm_factor = 1.0 / math.sqrt(self.head_dim)
+ self.beta = 1.0
+ self.layer_idx = layer_idx
+ if layer_idx is None:
+ logger.warning_once(
+ f"Instantiating {self.__class__.__name__} without passing a `layer_idx` is not recommended and will "
+ "lead to errors during the forward call if caching is used. Please make sure to provide a `layer_idx` "
+ "when creating this class."
+ )
+
+ self.query_key_value = nn.Linear(self.hidden_size, 3 * self.hidden_size, bias=True)
+ self.dense = nn.Linear(self.hidden_size, self.hidden_size)
+ self.attention_dropout = nn.Dropout(config.attention_dropout)
+
+ def _reshape(self, fused_qkv: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ """
+ Split the last dimension into (num_heads, head_dim) and reshapes to (bs, heads, len, dim) shape
+ without making any copies, results share same memory storage as `fused_qkv`
+
+ Args:
+ fused_qkv (`torch.tensor`): [batch_size, seq_length, num_heads * 3 * head_dim]
+
+ Returns:
+ query: [batch_size, num_heads, seq_length, head_dim]
+ key: [batch_size, num_heads, seq_length, head_dim]
+ value: [batch_size, num_heads, seq_length, head_dim]
+ """
+ batch_size, seq_length, three_times_hidden_size = fused_qkv.shape
+ fused_qkv = fused_qkv.view(batch_size, seq_length, self.num_heads, 3, self.head_dim)
+ query_layer = fused_qkv[..., 0, :].transpose(1, 2)
+ key_layer = fused_qkv[..., 1, :].transpose(1, 2)
+ value_layer = fused_qkv[..., 2, :].transpose(1, 2)
+ return query_layer, key_layer, value_layer
+
+ def _merge_heads(self, x: torch.Tensor) -> torch.Tensor:
+ """
+ Merge heads together over the last dimension
+
+ Args:
+ x (`torch.tensor`): [batch_size * num_heads, seq_length, head_dim]
+
+ Returns:
+ torch.tensor: [batch_size, seq_length, num_heads * head_dim]
+ """
+ # What we want to achieve is:
+ # batch_size * num_heads, seq_length, head_dim -> batch_size, seq_length, num_heads * head_dim
+ batch_size_and_num_heads, seq_length, _ = x.shape
+ batch_size = batch_size_and_num_heads // self.num_heads
+
+ # First view to decompose the batch size
+ # batch_size * num_heads, seq_length, head_dim -> batch_size, num_heads, seq_length, head_dim
+ x = x.view(batch_size, self.num_heads, seq_length, self.head_dim)
+
+ # batch_size, num_heads, seq_length, head_dim -> batch_size, seq_length, num_heads, head_dim
+ x = x.permute(0, 2, 1, 3)
+
+ # batch_size, seq_length, num_heads, head_dim -> batch_size, seq_length, num_heads * head_dim
+ return x.reshape(batch_size, seq_length, self.num_heads * self.head_dim)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ residual: torch.Tensor,
+ alibi: torch.Tensor,
+ attention_mask: torch.Tensor,
+ layer_past: Optional[Cache] = None,
+ head_mask: Optional[torch.Tensor] = None,
+ use_cache: bool = False,
+ output_attentions: bool = False,
+ cache_position: Optional[torch.LongTensor] = None,
+ ):
+ batch_size, q_length, _ = hidden_states.shape
+ fused_qkv = self.query_key_value(hidden_states) # [batch_size, seq_length, 3 x hidden_size]
+ # 3 x [batch_size, num_heads, seq_length, head_dim]
+ query_layer, key_layer, value_layer = self._reshape(fused_qkv)
+
+ if layer_past is not None:
+ cache_kwargs = {"cache_position": cache_position}
+ key_layer, value_layer = layer_past.update(key_layer, value_layer, self.layer_idx, cache_kwargs)
+
+ # reshape qkv for further computations
+ query_layer = query_layer.reshape(batch_size * self.num_heads, -1, self.head_dim)
+ key_layer = key_layer.reshape(batch_size * self.num_heads, -1, self.head_dim).transpose(-1, -2)
+ value_layer = value_layer.reshape(batch_size * self.num_heads, -1, self.head_dim)
+
+ # [batch_size * num_heads, q_length, kv_length]
+ attention_scores = alibi.baddbmm(
+ batch1=query_layer,
+ batch2=key_layer,
+ beta=self.beta,
+ alpha=self.inv_norm_factor,
+ )
+
+ # change view to [batch_size, num_heads, q_length, kv_length]
+ attn_weights = attention_scores.view(batch_size, self.num_heads, q_length, -1)
+ if attention_mask is not None: # no matter the length, we just slice it
+ causal_mask = attention_mask[:, :, :, : key_layer.shape[-1]]
+ attn_weights = attn_weights + causal_mask
+
+ # cast attention scores to fp32, compute scaled softmax and cast back to initial dtype
+ attention_probs = F.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_layer.dtype)
+
+ # [batch_size, num_heads, q_length, kv_length]
+ attention_probs = self.attention_dropout(attention_probs)
+
+ if head_mask is not None:
+ attention_probs = attention_probs * head_mask
+
+ # change view [batch_size x num_heads, q_length, kv_length]
+ attention_probs_reshaped = attention_probs.view(batch_size * self.num_heads, q_length, -1)
+
+ # matmul: [batch_size * num_heads, q_length, head_dim]
+ context_layer = torch.bmm(attention_probs_reshaped, value_layer)
+
+ # change view [batch_size, q_length, num_heads * head_dim]
+ context_layer = self._merge_heads(context_layer)
+
+ # aggregate results across tp ranks. See here: https://github.com/pytorch/pytorch/issues/76232
+ if self.pretraining_tp > 1 and self.slow_but_exact:
+ slices = self.hidden_size / self.pretraining_tp
+ output_tensor = torch.zeros_like(context_layer)
+ for i in range(self.pretraining_tp):
+ output_tensor = output_tensor + F.linear(
+ context_layer[:, :, int(i * slices) : int((i + 1) * slices)],
+ self.dense.weight[:, int(i * slices) : int((i + 1) * slices)],
+ )
+ else:
+ output_tensor = self.dense(context_layer)
+
+ output_tensor = dropout_add(output_tensor, residual, self.hidden_dropout, self.training)
+
+ outputs = (output_tensor, layer_past)
+ if output_attentions:
+ outputs += (attention_probs,)
+
+ return outputs
+
+
+class BloomMLP(nn.Module):
+ def __init__(self, config: BloomConfig):
+ super().__init__()
+ hidden_size = config.hidden_size
+
+ self.pretraining_tp = config.pretraining_tp
+ self.slow_but_exact = config.slow_but_exact
+ self.dense_h_to_4h = nn.Linear(hidden_size, 4 * hidden_size)
+ self.gelu_impl = BloomGelu()
+ self.dense_4h_to_h = nn.Linear(4 * hidden_size, hidden_size)
+ self.hidden_dropout = config.hidden_dropout
+
+ def forward(self, hidden_states: torch.Tensor, residual: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.gelu_impl(self.dense_h_to_4h(hidden_states))
+
+ if self.pretraining_tp > 1 and self.slow_but_exact:
+ intermediate_output = torch.zeros_like(residual)
+ slices = self.dense_4h_to_h.weight.shape[-1] / self.pretraining_tp
+ for i in range(self.pretraining_tp):
+ intermediate_output = intermediate_output + F.linear(
+ hidden_states[:, :, int(i * slices) : int((i + 1) * slices)],
+ self.dense_4h_to_h.weight[:, int(i * slices) : int((i + 1) * slices)],
+ )
+ else:
+ intermediate_output = self.dense_4h_to_h(hidden_states)
+
+ output = dropout_add(intermediate_output, residual, self.hidden_dropout, self.training)
+
+ return output
+
+
+class BloomBlock(nn.Module):
+ def __init__(self, config: BloomConfig, layer_idx: Optional[int] = None):
+ super().__init__()
+ hidden_size = config.hidden_size
+
+ self.input_layernorm = LayerNorm(hidden_size, eps=config.layer_norm_epsilon)
+ self.num_heads = config.n_head
+ self.self_attention = BloomAttention(config, layer_idx)
+ self.post_attention_layernorm = LayerNorm(hidden_size, eps=config.layer_norm_epsilon)
+
+ self.mlp = BloomMLP(config)
+
+ self.apply_residual_connection_post_layernorm = config.apply_residual_connection_post_layernorm
+ self.hidden_dropout = config.hidden_dropout
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ alibi: torch.Tensor,
+ attention_mask: torch.Tensor,
+ layer_past: Optional[Cache] = None,
+ head_mask: Optional[torch.Tensor] = None,
+ use_cache: bool = False,
+ output_attentions: bool = False,
+ cache_position: Optional[torch.LongTensor] = None,
+ ):
+ # hidden_states: [batch_size, seq_length, hidden_size]
+
+ # Layer norm at the beginning of the transformer layer.
+ layernorm_output = self.input_layernorm(hidden_states)
+
+ # Layer norm post the self attention.
+ if self.apply_residual_connection_post_layernorm:
+ residual = layernorm_output
+ else:
+ residual = hidden_states
+
+ # Self attention.
+ attn_outputs = self.self_attention(
+ layernorm_output,
+ residual,
+ layer_past=layer_past,
+ attention_mask=attention_mask,
+ alibi=alibi,
+ head_mask=head_mask,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ cache_position=cache_position,
+ )
+
+ attention_output = attn_outputs[0]
+
+ outputs = attn_outputs[1:]
+
+ layernorm_output = self.post_attention_layernorm(attention_output)
+
+ # Get residual
+ if self.apply_residual_connection_post_layernorm:
+ residual = layernorm_output
+ else:
+ residual = attention_output
+
+ # MLP.
+ output = self.mlp(layernorm_output, residual)
+
+ if use_cache:
+ outputs = (output,) + outputs
+ else:
+ outputs = (output,) + outputs[1:]
+
+ return outputs # hidden_states, past_kv, attentions
+
+
+class BloomPreTrainedModel(PreTrainedModel):
+ config_class = BloomConfig
+ base_model_prefix = "transformer"
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["BloomBlock"]
+ _skip_keys_device_placement = "past_key_values"
+ _supports_cache_class = True
+ _supports_static_cache = True
+ _supports_quantized_cache = True
+
+ def __init__(self, *inputs, **kwargs):
+ super().__init__(*inputs, **kwargs)
+
+ def _init_weights(self, module: nn.Module):
+ """Initialize the weights."""
+ if isinstance(module, nn.Linear):
+ # Slightly different from the TF version which uses truncated_normal for initialization
+ # cf https://github.com/pytorch/pytorch/pull/5617
+ module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+ if module.bias is not None:
+ module.bias.data.zero_()
+ elif isinstance(module, nn.Embedding):
+ module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+ if module.padding_idx is not None:
+ module.weight.data[module.padding_idx].zero_()
+ elif isinstance(module, LayerNorm):
+ module.bias.data.zero_()
+ module.weight.data.fill_(1.0)
+
+
+BLOOM_START_DOCSTRING = r"""
+
+ This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
+ library implements for all its model (such as downloading or saving, resizing the input embeddings etc.)
+
+ This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
+ Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
+ and behavior.
+
+ Parameters:
+ config ([`BloomConfig`]): Model configuration class with all the parameters of the model.
+ Initializing with a config file does not load the weights associated with the model, only the
+ configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+"""
+
+BLOOM_INPUTS_DOCSTRING = r"""
+ Args:
+ input_ids (`torch.LongTensor` of shape `(batch_size, input_ids_length)`):
+ `input_ids_length` = `sequence_length` if `past_key_values` is `None` else `past_key_values[0][0].shape[2]`
+ (`sequence_length` of input past key value states). Indices of input sequence tokens in the vocabulary.
+
+ If `past_key_values` is used, only `input_ids` that do not have their past calculated should be passed as
+ `input_ids`.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are input IDs?](../glossary#input-ids)
+ past_key_values (`Cache` or `tuple(tuple(torch.FloatTensor))`, *optional*):
+ Pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
+ blocks) that can be used to speed up sequential decoding. This typically consists in the `past_key_values`
+ returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`.
+
+ Two formats are allowed:
+ - a [`~cache_utils.Cache`] instance, see our
+ [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache);
+ - Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of
+ shape `(batch_size, num_heads, sequence_length, embed_size_per_head)`). This is also known as the legacy
+ cache format.
+
+ The model will output the same cache format that is fed as input. If no `past_key_values` are passed, the
+ legacy cache format will be returned.
+
+ If `past_key_values` are used, the user can optionally input only the last `input_ids` (those that don't
+ have their past key value states given to this model) of shape `(batch_size, 1)` instead of all `input_ids`
+ of shape `(batch_size, sequence_length)`.
+ attention_mask (`torch.FloatTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+
+ - 1 for tokens that are **not masked**,
+ - 0 for tokens that are **masked**.
+
+ [What are attention masks?](../glossary#attention-mask)
+ head_mask (`torch.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*):
+ Mask to nullify selected heads of the self-attention modules. Mask values selected in `[0, 1]`:
+
+ - 1 indicates the head is **not masked**,
+ - 0 indicates the head is **masked**.
+
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+ Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
+ is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
+ model's internal embedding lookup matrix.
+
+ If `past_key_values` is used, optionally only the last `inputs_embeds` have to be input (see
+ `past_key_values`).
+ use_cache (`bool`, *optional*):
+ If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
+ `past_key_values`).
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
+ tensors for more detail.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+ more detail.
+ return_dict (`bool`, *optional*):
+ Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.
+ cache_position (`torch.LongTensor` of shape `(sequence_length)`, *optional*):
+ Indices depicting the position of the input sequence tokens in the sequence. Contrarily to `position_ids`,
+ this tensor is not affected by padding. It is used to update the cache in the correct position and to infer
+ the complete sequence length.
+"""
+
+
+@add_start_docstrings(
+ "The bare Bloom Model transformer outputting raw hidden-states without any specific head on top.",
+ BLOOM_START_DOCSTRING,
+)
+class BloomModel(BloomPreTrainedModel):
+ def __init__(self, config: BloomConfig):
+ super().__init__(config)
+
+ self.embed_dim = config.hidden_size
+ self.num_heads = config.n_head
+
+ # Embedding + LN Embedding
+ self.word_embeddings = nn.Embedding(config.vocab_size, self.embed_dim)
+ self.word_embeddings_layernorm = LayerNorm(self.embed_dim, eps=config.layer_norm_epsilon)
+
+ # Transformer blocks
+ self.h = nn.ModuleList([BloomBlock(config, layer_idx=i) for i in range(config.num_hidden_layers)])
+
+ # Final Layer Norm
+ self.ln_f = LayerNorm(self.embed_dim, eps=config.layer_norm_epsilon)
+
+ self.gradient_checkpointing = False
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def build_alibi_tensor(self, attention_mask: torch.Tensor, num_heads: int, dtype: torch.dtype) -> torch.Tensor:
+ return build_alibi_tensor(attention_mask, num_heads, dtype)
+
+ def get_input_embeddings(self):
+ return self.word_embeddings
+
+ def set_input_embeddings(self, new_embeddings: torch.Tensor):
+ self.word_embeddings = new_embeddings
+
+ @add_start_docstrings_to_model_forward(BLOOM_INPUTS_DOCSTRING)
+ @add_code_sample_docstrings(
+ checkpoint=_CHECKPOINT_FOR_DOC,
+ output_type=BaseModelOutputWithPastAndCrossAttentions,
+ config_class=_CONFIG_FOR_DOC,
+ )
+ def forward(
+ self,
+ input_ids: Optional[torch.LongTensor] = None,
+ past_key_values: Optional[Union[Cache, Tuple[Tuple[torch.Tensor, torch.Tensor], ...]]] = None,
+ attention_mask: Optional[torch.Tensor] = None,
+ head_mask: Optional[torch.LongTensor] = None,
+ inputs_embeds: Optional[torch.LongTensor] = None,
+ use_cache: Optional[bool] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ cache_position: Optional[torch.LongTensor] = None,
+ **deprecated_arguments,
+ ) -> Union[Tuple[torch.Tensor, ...], BaseModelOutputWithPastAndCrossAttentions]:
+ if deprecated_arguments.pop("position_ids", False) is not False:
+ # `position_ids` could have been `torch.Tensor` or `None` so defaulting pop to `False` allows to detect if users were passing explicitly `None`
+ warnings.warn(
+ "`position_ids` have no functionality in BLOOM and will be removed in v5.0.0. You can safely ignore"
+ " passing `position_ids`.",
+ FutureWarning,
+ )
+ if len(deprecated_arguments) > 0:
+ raise ValueError(f"Got unexpected arguments: {deprecated_arguments}")
+
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+ if self.gradient_checkpointing and self.training and use_cache:
+ logger.warning_once(
+ "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
+ )
+ use_cache = False
+
+ if inputs_embeds is None:
+ inputs_embeds = self.word_embeddings(input_ids)
+
+ # kept for BC (non `Cache` `past_key_values` inputs)
+ return_legacy_cache = False
+ if use_cache and not isinstance(past_key_values, Cache):
+ return_legacy_cache = True
+ if past_key_values is None:
+ past_key_values = DynamicCache()
+ else:
+ past_key_values = DynamicCache.from_legacy_cache(past_key_values)
+ logger.warning_once(
+ "We detected that you are passing `past_key_values` as a tuple of tuples. This is deprecated and "
+ "will be removed in v4.47. Please convert your cache or use an appropriate `Cache` class "
+ "(https://huggingface.co/docs/transformers/kv_cache#legacy-cache-format)"
+ )
+
+ batch_size, seq_length, _ = inputs_embeds.shape
+ past_length = past_key_values.get_seq_length() if past_key_values is not None else 0
+ seq_length_with_past = seq_length + past_length
+ if cache_position is None:
+ cache_position = torch.arange(past_length, past_length + seq_length, device=inputs_embeds.device)
+
+ # Prepare head mask if needed
+ # 1.0 in head_mask indicate we keep the head
+ # attention_probs has shape batch_size x num_heads x N x N
+ # head_mask has shape n_layer x batch x num_heads x N x N
+ head_mask = self.get_head_mask(head_mask, self.config.n_layer)
+ hidden_states = self.word_embeddings_layernorm(inputs_embeds)
+
+ next_decoder_cache = None
+ all_self_attentions = () if output_attentions else None
+ all_hidden_states = () if output_hidden_states else None
+
+ # Compute alibi tensor: check build_alibi_tensor documentation
+ if attention_mask is None:
+ attention_mask = torch.ones((batch_size, seq_length_with_past), device=hidden_states.device)
+ else:
+ attention_mask = attention_mask.to(hidden_states.device)
+
+ alibi = self.build_alibi_tensor(attention_mask, self.num_heads, dtype=hidden_states.dtype)
+ causal_mask = self._update_causal_mask(
+ attention_mask, inputs_embeds, cache_position, past_key_values, output_attentions
+ )
+
+ for i, block in enumerate(self.h):
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ if self.gradient_checkpointing and self.training:
+ outputs = self._gradient_checkpointing_func(
+ block.__call__,
+ hidden_states,
+ alibi,
+ causal_mask,
+ past_key_values,
+ head_mask[i],
+ use_cache,
+ output_attentions,
+ cache_position,
+ )
+ else:
+ outputs = block(
+ hidden_states,
+ layer_past=past_key_values,
+ attention_mask=causal_mask,
+ head_mask=head_mask[i],
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ alibi=alibi,
+ cache_position=cache_position,
+ )
+
+ hidden_states = outputs[0]
+ if use_cache:
+ next_decoder_cache = outputs[1]
+
+ if output_attentions:
+ all_self_attentions = all_self_attentions + (outputs[2 if use_cache else 1],)
+
+ # Add last hidden state
+ hidden_states = self.ln_f(hidden_states)
+
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ next_cache = next_decoder_cache if use_cache else None
+ if return_legacy_cache:
+ next_cache = next_cache.to_legacy_cache()
+
+ if not return_dict:
+ return tuple(
+ v for v in [hidden_states, next_cache, all_hidden_states, all_self_attentions] if v is not None
+ )
+
+ return BaseModelOutputWithPastAndCrossAttentions(
+ last_hidden_state=hidden_states,
+ past_key_values=next_cache,
+ hidden_states=all_hidden_states,
+ attentions=all_self_attentions,
+ )
+
+ # Copied from transformers.models.llama.modeling_llama.LlamaModel._update_causal_mask
+ def _update_causal_mask(
+ self,
+ attention_mask: torch.Tensor,
+ input_tensor: torch.Tensor,
+ cache_position: torch.Tensor,
+ past_key_values: Cache,
+ output_attentions: bool = False,
+ ):
+ if self.config._attn_implementation == "flash_attention_2":
+ if attention_mask is not None and (attention_mask == 0.0).any():
+ return attention_mask
+ return None
+ if self.config._attn_implementation == "flex_attention":
+ if isinstance(attention_mask, torch.Tensor):
+ attention_mask = make_flex_block_causal_mask(attention_mask)
+ if isinstance(attention_mask, BlockMask):
+ return attention_mask
+
+ # For SDPA, when possible, we will rely on its `is_causal` argument instead of its `attn_mask` argument, in
+ # order to dispatch on Flash Attention 2. This feature is not compatible with static cache, as SDPA will fail
+ # to infer the attention mask.
+ past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0
+ using_static_cache = isinstance(past_key_values, StaticCache)
+
+ # When output attentions is True, sdpa implementation's forward method calls the eager implementation's forward
+ if self.config._attn_implementation == "sdpa" and not using_static_cache and not output_attentions:
+ if AttentionMaskConverter._ignore_causal_mask_sdpa(
+ attention_mask,
+ inputs_embeds=input_tensor,
+ past_key_values_length=past_seen_tokens,
+ is_training=self.training,
+ ):
+ return None
+
+ dtype, device = input_tensor.dtype, input_tensor.device
+ sequence_length = input_tensor.shape[1]
+ if using_static_cache:
+ target_length = past_key_values.get_max_cache_shape()
+ else:
+ target_length = (
+ attention_mask.shape[-1]
+ if isinstance(attention_mask, torch.Tensor)
+ else past_seen_tokens + sequence_length + 1
+ )
+
+ # In case the provided `attention` mask is 2D, we generate a causal mask here (4D).
+ causal_mask = self._prepare_4d_causal_attention_mask_with_cache_position(
+ attention_mask,
+ sequence_length=sequence_length,
+ target_length=target_length,
+ dtype=dtype,
+ device=device,
+ cache_position=cache_position,
+ batch_size=input_tensor.shape[0],
+ )
+
+ if (
+ self.config._attn_implementation == "sdpa"
+ and attention_mask is not None
+ and attention_mask.device.type in ["cuda", "xpu"]
+ and not output_attentions
+ ):
+ # Attend to all tokens in fully masked rows in the causal_mask, for example the relevant first rows when
+ # using left padding. This is required by F.scaled_dot_product_attention memory-efficient attention path.
+ # Details: https://github.com/pytorch/pytorch/issues/110213
+ min_dtype = torch.finfo(dtype).min
+ causal_mask = AttentionMaskConverter._unmask_unattended(causal_mask, min_dtype)
+
+ return causal_mask
+
+ @staticmethod
+ # Copied from transformers.models.llama.modeling_llama.LlamaModel._prepare_4d_causal_attention_mask_with_cache_position
+ def _prepare_4d_causal_attention_mask_with_cache_position(
+ attention_mask: torch.Tensor,
+ sequence_length: int,
+ target_length: int,
+ dtype: torch.dtype,
+ device: torch.device,
+ cache_position: torch.Tensor,
+ batch_size: int,
+ **kwargs,
+ ):
+ """
+ Creates a causal 4D mask of shape `(batch_size, 1, query_length, key_value_length)` from a 2D mask of shape
+ `(batch_size, key_value_length)`, or if the input `attention_mask` is already 4D, do nothing.
+
+ Args:
+ attention_mask (`torch.Tensor`):
+ A 2D attention mask of shape `(batch_size, key_value_length)` or a 4D attention mask of shape
+ `(batch_size, 1, query_length, key_value_length)`.
+ sequence_length (`int`):
+ The sequence length being processed.
+ target_length (`int`):
+ The target length: when generating with static cache, the mask should be as long as the static cache,
+ to account for the 0 padding, the part of the cache that is not filled yet.
+ dtype (`torch.dtype`):
+ The dtype to use for the 4D attention mask.
+ device (`torch.device`):
+ The device to place the 4D attention mask on.
+ cache_position (`torch.Tensor`):
+ Indices depicting the position of the input sequence tokens in the sequence.
+ batch_size (`torch.Tensor`):
+ Batch size.
+ """
+ if attention_mask is not None and attention_mask.dim() == 4:
+ # In this case we assume that the mask comes already in inverted form and requires no inversion or slicing.
+ causal_mask = attention_mask
+ else:
+ min_dtype = torch.finfo(dtype).min
+ causal_mask = torch.full(
+ (sequence_length, target_length), fill_value=min_dtype, dtype=dtype, device=device
+ )
+ if sequence_length != 1:
+ causal_mask = torch.triu(causal_mask, diagonal=1)
+ causal_mask *= torch.arange(target_length, device=device) > cache_position.reshape(-1, 1)
+ causal_mask = causal_mask[None, None, :, :].expand(batch_size, 1, -1, -1)
+ if attention_mask is not None:
+ causal_mask = causal_mask.clone() # copy to contiguous memory for in-place edit
+ mask_length = attention_mask.shape[-1]
+ padding_mask = causal_mask[:, :, :, :mask_length] + attention_mask[:, None, None, :].to(
+ causal_mask.device
+ )
+ padding_mask = padding_mask == 0
+ causal_mask[:, :, :, :mask_length] = causal_mask[:, :, :, :mask_length].masked_fill(
+ padding_mask, min_dtype
+ )
+
+ return causal_mask
+
+
+@add_start_docstrings(
+ """
+ The Bloom Model transformer with a language modeling head on top (linear layer with weights tied to the input
+ embeddings).
+ """,
+ BLOOM_START_DOCSTRING,
+)
+class BloomForCausalLM(BloomPreTrainedModel, GenerationMixin):
+ _tied_weights_keys = ["lm_head.weight"]
+
+ def __init__(self, config: BloomConfig):
+ super().__init__(config)
+ self.transformer = BloomModel(config)
+ self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_output_embeddings(self):
+ return self.lm_head
+
+ def set_output_embeddings(self, new_embeddings: torch.Tensor):
+ self.lm_head = new_embeddings
+
+ def prepare_inputs_for_generation(
+ self,
+ input_ids,
+ past_key_values=None,
+ attention_mask=None,
+ inputs_embeds=None,
+ cache_position=None,
+ use_cache=True,
+ **kwargs,
+ ):
+ # Overwriten because of the fixed-shape attention mask creation
+
+ # If we have cache: let's slice `input_ids` through `cache_position`, to keep only the unprocessed tokens
+ # Exception 1: when passing input_embeds, input_ids may be missing entries
+ # Exception 2: some generation methods do special slicing of input_ids, so we don't need to do it here
+ # Exception 3: with synced GPUs cache_position may go out of bounds, but we only want dummy token in that case.
+ # (we can't check exception 3 while compiling)
+ # Exception 4: If input_embeds are passed then slice it through `cache_position`, to keep only the unprocessed tokens and
+ # generate the first token for each sequence. Later use the generated Input ids for continuation.
+ if past_key_values is not None:
+ if inputs_embeds is not None and input_ids.shape[1] == 0: # Exception 4
+ inputs_embeds = inputs_embeds[:, -cache_position.shape[0] :]
+ elif (
+ inputs_embeds is not None # Exception 1
+ or cache_position[-1] >= input_ids.shape[1] # Exception 3
+ ):
+ input_ids = input_ids[:, -cache_position.shape[0] :]
+ elif input_ids.shape[1] != cache_position.shape[0]: # Default case (the "else", a no op, is Exception 2)
+ input_ids = input_ids[:, cache_position]
+
+ # if `inputs_embeds` are passed, we only want to use them in the 1st generation step
+ if inputs_embeds is not None and len(cache_position) == inputs_embeds.shape[1]:
+ model_inputs = {"inputs_embeds": inputs_embeds, "input_ids": None}
+ else:
+ # This `clone` call is needed to avoid recapturing cuda graphs with `torch.compile`'s `mode="reduce-overhead`, as otherwise the
+ # input `position_ids` would have various stride during the decoding. Here, simply using `.contiguous()` is not sufficient as in
+ # the batch size = 1 case, `position_ids` is already contiguous but with varying stride which retriggers a capture.
+ model_inputs = {"input_ids": input_ids.clone(memory_format=torch.contiguous_format), "inputs_embeds": None}
+
+ # This part differs from other models because BLOOM needs a 2D mask to construct alibi tensor
+ # The only difference is the usage of 2D instead of 4D mask, but the shape will be static
+ if isinstance(past_key_values, StaticCache) and attention_mask is not None:
+ target_length = past_key_values.get_max_cache_shape()
+ batch_size, seq_length = attention_mask.shape
+ diff = target_length - seq_length
+
+ new_attn_mask = torch.zeros(batch_size, diff, device=attention_mask.device, dtype=attention_mask.dtype)
+ attention_mask = torch.cat(
+ [attention_mask, new_attn_mask],
+ dim=-1,
+ )
+
+ model_inputs.update(
+ {
+ "cache_position": cache_position,
+ "past_key_values": past_key_values,
+ "use_cache": use_cache,
+ "attention_mask": attention_mask,
+ }
+ )
+ return model_inputs
+
+ @add_start_docstrings_to_model_forward(BLOOM_INPUTS_DOCSTRING)
+ @add_code_sample_docstrings(
+ checkpoint=_CHECKPOINT_FOR_DOC,
+ output_type=CausalLMOutputWithCrossAttentions,
+ config_class=_CONFIG_FOR_DOC,
+ )
+ def forward(
+ self,
+ input_ids: Optional[torch.LongTensor] = None,
+ past_key_values: Optional[Union[Cache, Tuple[Tuple[torch.Tensor, torch.Tensor], ...]]] = None,
+ attention_mask: Optional[torch.Tensor] = None,
+ head_mask: Optional[torch.Tensor] = None,
+ inputs_embeds: Optional[torch.Tensor] = None,
+ labels: Optional[torch.Tensor] = None,
+ use_cache: Optional[bool] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ cache_position: Optional[torch.LongTensor] = None,
+ **deprecated_arguments,
+ ) -> Union[Tuple[torch.Tensor], CausalLMOutputWithCrossAttentions]:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for language modeling. Note that the labels **are shifted** inside the model, i.e. you can set
+ `labels = input_ids` Indices are selected in `[-100, 0, ..., config.vocab_size]` All labels set to `-100`
+ are ignored (masked), the loss is only computed for labels in `[0, ..., config.vocab_size]`
+ """
+ # Bloom has deprecated kwargs, so we need to pop num_items_in_batch explicitly
+ num_items_in_batch = deprecated_arguments.pop("num_items_in_batch", None)
+ if deprecated_arguments.pop("position_ids", False) is not False:
+ # `position_ids` could have been `torch.Tensor` or `None` so defaulting pop to `False` allows to detect if users were passing explicitly `None`
+ warnings.warn(
+ "`position_ids` have no functionality in BLOOM and will be removed in v5.0.0. You can safely ignore"
+ " passing `position_ids`.",
+ FutureWarning,
+ )
+ if len(deprecated_arguments) > 0:
+ raise ValueError(f"Got unexpected arguments: {deprecated_arguments}")
+
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+ transformer_outputs = self.transformer(
+ input_ids,
+ past_key_values=past_key_values,
+ attention_mask=attention_mask,
+ head_mask=head_mask,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ cache_position=cache_position,
+ )
+ hidden_states = transformer_outputs[0]
+
+ lm_logits = self.lm_head(hidden_states)
+
+ loss = None
+ if labels is not None:
+ # move labels to correct device to enable model parallelism
+ labels = labels.to(lm_logits.device)
+ # Flatten the tokens
+ loss = self.loss_function(
+ lm_logits,
+ labels,
+ vocab_size=self.config.vocab_size,
+ num_items_in_batch=num_items_in_batch,
+ )
+
+ if not return_dict:
+ output = (lm_logits,) + transformer_outputs[1:]
+ return ((loss,) + output) if loss is not None else output
+
+ return CausalLMOutputWithCrossAttentions(
+ loss=loss,
+ logits=lm_logits,
+ past_key_values=transformer_outputs.past_key_values,
+ hidden_states=transformer_outputs.hidden_states,
+ attentions=transformer_outputs.attentions,
+ )
+
+ def _reorder_cache(
+ self, past: Tuple[Tuple[torch.Tensor, torch.Tensor], ...], beam_idx: torch.LongTensor
+ ) -> Tuple[Tuple[torch.Tensor, torch.Tensor], ...]:
+ """
+ This function is used to re-order the `past_key_values` cache if [`~PreTrainedModel.beam_search`] or
+ [`~PreTrainedModel.beam_sample`] is called. This is required to match `past_key_values` with the correct
+ beam_idx at every generation step.
+
+ Output shares the same memory storage as `past`.
+ """
+ # Get a copy of `beam_idx` on all the devices where we need those indices.
+ device_to_beam_idx = {
+ past_state.device: beam_idx.to(past_state.device) for layer_past in past for past_state in layer_past
+ }
+ reordered_past = tuple(
+ (
+ layer_past[0].index_select(0, device_to_beam_idx[layer_past[0].device]),
+ layer_past[1].index_select(0, device_to_beam_idx[layer_past[0].device]),
+ )
+ for layer_past in past
+ )
+ return reordered_past
+
+
+@add_start_docstrings(
+ """
+ The Bloom Model transformer with a sequence classification head on top (linear layer).
+
+ [`BloomForSequenceClassification`] uses the last token in order to do the classification, as other causal models
+ (e.g. GPT-1) do.
+
+ Since it does classification on the last token, it requires to know the position of the last token. If a
+ `pad_token_id` is defined in the configuration, it finds the last token that is not a padding token in each row. If
+ no `pad_token_id` is defined, it simply takes the last value in each row of the batch. Since it cannot guess the
+ padding tokens when `inputs_embeds` are passed instead of `input_ids`, it does the same (take the last value in
+ each row of the batch).
+ """,
+ BLOOM_START_DOCSTRING,
+)
+class BloomForSequenceClassification(BloomPreTrainedModel):
+ def __init__(self, config: BloomConfig):
+ super().__init__(config)
+ self.num_labels = config.num_labels
+ self.transformer = BloomModel(config)
+ self.score = nn.Linear(config.hidden_size, config.num_labels, bias=False)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @add_start_docstrings_to_model_forward(BLOOM_INPUTS_DOCSTRING)
+ @add_code_sample_docstrings(
+ checkpoint=_CHECKPOINT_FOR_DOC,
+ output_type=SequenceClassifierOutputWithPast,
+ config_class=_CONFIG_FOR_DOC,
+ )
+ def forward(
+ self,
+ input_ids: Optional[torch.LongTensor] = None,
+ past_key_values: Optional[Union[Cache, Tuple[Tuple[torch.Tensor, torch.Tensor], ...]]] = None,
+ attention_mask: Optional[torch.Tensor] = None,
+ head_mask: Optional[torch.Tensor] = None,
+ inputs_embeds: Optional[torch.Tensor] = None,
+ labels: Optional[torch.Tensor] = None,
+ use_cache: Optional[bool] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ **deprecated_arguments,
+ ) -> Union[Tuple[torch.Tensor], SequenceClassifierOutputWithPast]:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ if deprecated_arguments.pop("position_ids", False) is not False:
+ # `position_ids` could have been `torch.Tensor` or `None` so defaulting pop to `False` allows to detect if users were passing explicitly `None`
+ warnings.warn(
+ "`position_ids` have no functionality in BLOOM and will be removed in v5.0.0. You can safely ignore"
+ " passing `position_ids`.",
+ FutureWarning,
+ )
+ if len(deprecated_arguments) > 0:
+ raise ValueError(f"Got unexpected arguments: {deprecated_arguments}")
+
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+ transformer_outputs = self.transformer(
+ input_ids,
+ past_key_values=past_key_values,
+ attention_mask=attention_mask,
+ head_mask=head_mask,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ hidden_states = transformer_outputs[0]
+ logits = self.score(hidden_states)
+
+ if input_ids is not None:
+ batch_size = input_ids.shape[0]
+ else:
+ batch_size = inputs_embeds.shape[0]
+
+ if self.config.pad_token_id is None and batch_size != 1:
+ raise ValueError("Cannot handle batch sizes > 1 if no padding token is defined.")
+ if self.config.pad_token_id is None:
+ last_non_pad_token = -1
+ elif input_ids is not None:
+ # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
+ non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
+ token_indices = torch.arange(input_ids.shape[-1], device=logits.device, dtype=torch.int32)
+ last_non_pad_token = (token_indices * non_pad_mask).argmax(-1)
+ else:
+ last_non_pad_token = -1
+ logger.warning_once(
+ f"{self.__class__.__name__} will not detect padding tokens in `inputs_embeds`. Results may be "
+ "unexpected if using padding tokens in conjunction with `inputs_embeds.`"
+ )
+
+ pooled_logits = logits[torch.arange(batch_size, device=logits.device), last_non_pad_token]
+
+ loss = None
+ if labels is not None:
+ if self.config.problem_type is None:
+ if self.num_labels == 1:
+ self.config.problem_type = "regression"
+ elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+ self.config.problem_type = "single_label_classification"
+ else:
+ self.config.problem_type = "multi_label_classification"
+
+ if self.config.problem_type == "regression":
+ loss_fct = MSELoss()
+ if self.num_labels == 1:
+ loss = loss_fct(pooled_logits.squeeze(), labels.squeeze())
+ else:
+ loss = loss_fct(pooled_logits, labels)
+ elif self.config.problem_type == "single_label_classification":
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(pooled_logits, labels)
+ elif self.config.problem_type == "multi_label_classification":
+ loss_fct = BCEWithLogitsLoss()
+ loss = loss_fct(pooled_logits, labels)
+ if not return_dict:
+ output = (pooled_logits,) + transformer_outputs[1:]
+ return ((loss,) + output) if loss is not None else output
+
+ return SequenceClassifierOutputWithPast(
+ loss=loss,
+ logits=pooled_logits,
+ past_key_values=transformer_outputs.past_key_values,
+ hidden_states=transformer_outputs.hidden_states,
+ attentions=transformer_outputs.attentions,
+ )
+
+
+@add_start_docstrings(
+ """
+ Bloom Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g. for
+ Named-Entity-Recognition (NER) tasks.
+ """,
+ BLOOM_START_DOCSTRING,
+)
+class BloomForTokenClassification(BloomPreTrainedModel):
+ def __init__(self, config: BloomConfig):
+ super().__init__(config)
+ self.num_labels = config.num_labels
+
+ self.transformer = BloomModel(config)
+ if hasattr(config, "classifier_dropout") and config.classifier_dropout is not None:
+ classifier_dropout = config.classifier_dropout
+ elif hasattr(config, "hidden_dropout") and config.hidden_dropout is not None:
+ classifier_dropout = config.hidden_dropout
+ else:
+ classifier_dropout = 0.1
+ self.dropout = nn.Dropout(classifier_dropout)
+ self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @add_start_docstrings_to_model_forward(BLOOM_INPUTS_DOCSTRING)
+ @add_code_sample_docstrings(
+ checkpoint=_CHECKPOINT_FOR_DOC,
+ output_type=TokenClassifierOutput,
+ config_class=_CONFIG_FOR_DOC,
+ )
+ def forward(
+ self,
+ input_ids: Optional[torch.LongTensor] = None,
+ past_key_values: Optional[Union[Cache, Tuple[Tuple[torch.Tensor, torch.Tensor], ...]]] = None,
+ attention_mask: Optional[torch.Tensor] = None,
+ head_mask: Optional[torch.Tensor] = None,
+ inputs_embeds: Optional[torch.Tensor] = None,
+ labels: Optional[torch.Tensor] = None,
+ use_cache: Optional[bool] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ **deprecated_arguments,
+ ) -> Union[Tuple[torch.Tensor], TokenClassifierOutput]:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ if deprecated_arguments.pop("position_ids", False) is not False:
+ # `position_ids` could have been `torch.Tensor` or `None` so defaulting pop to `False` allows to detect if users were passing explicitly `None`
+ warnings.warn(
+ "`position_ids` have no functionality in BLOOM and will be removed in v5.0.0. You can safely ignore"
+ " passing `position_ids`.",
+ FutureWarning,
+ )
+ if len(deprecated_arguments) > 0:
+ raise ValueError(f"Got unexpected arguments: {deprecated_arguments}")
+
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+ transformer_outputs = self.transformer(
+ input_ids,
+ past_key_values=past_key_values,
+ attention_mask=attention_mask,
+ head_mask=head_mask,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ hidden_states = transformer_outputs[0]
+ hidden_states = self.dropout(hidden_states)
+ logits = self.classifier(hidden_states)
+
+ loss = None
+ if labels is not None:
+ # move labels to correct device to enable model parallelism
+ labels = labels.to(logits.device)
+ batch_size, seq_length = labels.shape
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(
+ logits.view(batch_size * seq_length, self.num_labels), labels.view(batch_size * seq_length)
+ )
+
+ if not return_dict:
+ output = (logits,) + transformer_outputs[2:]
+ return ((loss,) + output) if loss is not None else output
+
+ return TokenClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=transformer_outputs.hidden_states,
+ attentions=transformer_outputs.attentions,
+ )
+
+
+@add_start_docstrings(
+ """
+ The BLOOM Model transformer with a span classification head on top for extractive question-answering tasks like
+ SQuAD (a linear layers on top of the hidden-states output to compute `span start logits` and `span end logits`).
+ """,
+ BLOOM_START_DOCSTRING,
+)
+class BloomForQuestionAnswering(BloomPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+ self.transformer = BloomModel(config)
+ self.qa_outputs = nn.Linear(config.hidden_size, 2)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @add_start_docstrings_to_model_forward(BLOOM_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
+ def forward(
+ self,
+ input_ids: Optional[torch.LongTensor] = None,
+ attention_mask: Optional[torch.FloatTensor] = None,
+ position_ids: Optional[torch.LongTensor] = None,
+ head_mask: Optional[torch.FloatTensor] = None,
+ inputs_embeds: Optional[torch.FloatTensor] = None,
+ start_positions: Optional[torch.LongTensor] = None,
+ end_positions: Optional[torch.LongTensor] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ ) -> Union[Tuple, QuestionAnsweringModelOutput]:
+ r"""
+ start_positions (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for position (index) of the start of the labelled span for computing the token classification loss.
+ Positions are clamped to the length of the sequence (`sequence_length`). Position outside of the sequence
+ are not taken into account for computing the loss.
+ end_positions (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for position (index) of the end of the labelled span for computing the token classification loss.
+ Positions are clamped to the length of the sequence (`sequence_length`). Position outside of the sequence
+ are not taken into account for computing the loss.
+ """
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+ outputs = self.transformer(
+ input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ head_mask=head_mask,
+ inputs_embeds=inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ sequence_output = outputs[0]
+
+ logits = self.qa_outputs(sequence_output)
+ start_logits, end_logits = logits.split(1, dim=-1)
+ start_logits = start_logits.squeeze(-1).contiguous()
+ end_logits = end_logits.squeeze(-1).contiguous()
+
+ total_loss = None
+ if start_positions is not None and end_positions is not None:
+ # If we are on multi-GPU, split add a dimension
+ if len(start_positions.size()) > 1:
+ start_positions = start_positions.squeeze(-1)
+ if len(end_positions.size()) > 1:
+ end_positions = end_positions.squeeze(-1)
+ # sometimes the start/end positions are outside our model inputs, we ignore these terms
+ ignored_index = start_logits.size(1)
+ start_positions = start_positions.clamp(0, ignored_index)
+ end_positions = end_positions.clamp(0, ignored_index)
+
+ loss_fct = CrossEntropyLoss(ignore_index=ignored_index)
+ start_loss = loss_fct(start_logits, start_positions)
+ end_loss = loss_fct(end_logits, end_positions)
+ total_loss = (start_loss + end_loss) / 2
+
+ if not return_dict:
+ output = (start_logits, end_logits) + outputs[2:]
+ return ((total_loss,) + output) if total_loss is not None else output
+
+ return QuestionAnsweringModelOutput(
+ loss=total_loss,
+ start_logits=start_logits,
+ end_logits=end_logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = [
+ "BloomForCausalLM",
+ "BloomModel",
+ "BloomPreTrainedModel",
+ "BloomForSequenceClassification",
+ "BloomForTokenClassification",
+ "BloomForQuestionAnswering",
+]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/bloom/tokenization_bloom_fast.py b/vllm/lib/python3.10/site-packages/transformers/models/bloom/tokenization_bloom_fast.py
new file mode 100644
index 0000000000000000000000000000000000000000..c84322637cb7e879b2cf50fdbd81fdc79b08ed98
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/bloom/tokenization_bloom_fast.py
@@ -0,0 +1,152 @@
+# coding=utf-8
+# Copyright 2022 The HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tokenization classes for Bloom."""
+
+import pickle
+from typing import Optional, Tuple
+
+from ...tokenization_utils_base import BatchEncoding
+from ...tokenization_utils_fast import PreTrainedTokenizerFast
+from ...utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+VOCAB_FILES_NAMES = {"tokenizer_file": "tokenizer.json"}
+
+
+class BloomTokenizerFast(PreTrainedTokenizerFast):
+ """
+ Construct a "fast" Bloom tokenizer (backed by HuggingFace's *tokenizers* library). Based on byte-level
+ Byte-Pair-Encoding.
+
+ This tokenizer has been trained to treat spaces like parts of the tokens (a bit like sentencepiece) so a word will
+ be encoded differently whether it is at the beginning of the sentence (without space) or not:
+
+ ```python
+ >>> from transformers import BloomTokenizerFast
+
+ >>> tokenizer = BloomTokenizerFast.from_pretrained("bigscience/bloom")
+ >>> tokenizer("Hello world")["input_ids"]
+ [59414, 8876]
+
+ >>> tokenizer(" Hello world")["input_ids"]
+ [86153, 8876]
+ ```
+
+ You can get around that behavior by passing `add_prefix_space=True` when instantiating this tokenizer, but since
+ the model was not pretrained this way, it might yield a decrease in performance.
+
+
+
+ When used with `is_split_into_words=True`, this tokenizer needs to be instantiated with `add_prefix_space=True`.
+
+
+
+ This tokenizer inherits from [`PreTrainedTokenizerFast`] which contains most of the main methods. Users should
+ refer to this superclass for more information regarding those methods.
+
+ Args:
+ vocab_file (`str`):
+ Path to the vocabulary file.
+ merges_file (`str`):
+ Path to the merges file.
+ errors (`str`, *optional*, defaults to `"replace"`):
+ Paradigm to follow when decoding bytes to UTF-8. See
+ [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode) for more information.
+ unk_token (`str`, *optional*, defaults to `<|endoftext|>`):
+ The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this
+ token instead.
+ bos_token (`str`, *optional*, defaults to `<|endoftext|>`):
+ The beginning of sequence token.
+ eos_token (`str`, *optional*, defaults to `<|endoftext|>`):
+ The end of sequence token.
+ add_prefix_space (`bool`, *optional*, defaults to `False`):
+ Whether or not to add an initial space to the input. This allows to treat the leading word just as any
+ other word. (Bloom tokenizer detect beginning of words by the preceding space).
+ trim_offsets (`bool`, *optional*, defaults to `True`):
+ Whether or not the post-processing step should trim offsets to avoid including whitespaces.
+ """
+
+ vocab_files_names = VOCAB_FILES_NAMES
+ model_input_names = ["input_ids", "attention_mask"]
+ slow_tokenizer_class = None
+ # No `max_model_input_sizes` as BLOOM uses ALiBi positional embeddings
+
+ def __init__(
+ self,
+ vocab_file=None,
+ merges_file=None,
+ tokenizer_file=None,
+ unk_token="",
+ bos_token="",
+ eos_token="",
+ pad_token="",
+ add_prefix_space=False,
+ clean_up_tokenization_spaces=False,
+ **kwargs,
+ ):
+ super().__init__(
+ vocab_file=vocab_file,
+ merges_file=merges_file,
+ tokenizer_file=tokenizer_file,
+ unk_token=unk_token,
+ bos_token=bos_token,
+ eos_token=eos_token,
+ pad_token=pad_token,
+ add_prefix_space=add_prefix_space,
+ clean_up_tokenization_spaces=clean_up_tokenization_spaces,
+ **kwargs,
+ )
+ # TODO @ArthurZucker this can only work one way for now, to update later-on. Tests should also properly
+ # check this as they were green before.
+ pre_tok_state = pickle.dumps(self.backend_tokenizer.pre_tokenizer)
+ decoder_state = pickle.dumps(self.backend_tokenizer.decoder)
+
+ if add_prefix_space:
+ pre_tok_state = pre_tok_state.replace(b'"add_prefix_space":false', b'"add_prefix_space": true')
+ decoder_state = decoder_state.replace(b'"add_prefix_space":false', b'"add_prefix_space": true')
+ self.backend_tokenizer.pre_tokenizer = pickle.loads(pre_tok_state)
+ self.backend_tokenizer.decoder = pickle.loads(decoder_state)
+
+ self.add_prefix_space = add_prefix_space
+
+ def _batch_encode_plus(self, *args, **kwargs) -> BatchEncoding:
+ is_split_into_words = kwargs.get("is_split_into_words", False)
+ if not (self.add_prefix_space or not is_split_into_words):
+ raise Exception(
+ f"You need to instantiate {self.__class__.__name__} with add_prefix_space=True to use it with"
+ " pretokenized inputs."
+ )
+
+ return super()._batch_encode_plus(*args, **kwargs)
+
+ def _encode_plus(self, *args, **kwargs) -> BatchEncoding:
+ is_split_into_words = kwargs.get("is_split_into_words", False)
+
+ if not (self.add_prefix_space or not is_split_into_words):
+ raise Exception(
+ f"You need to instantiate {self.__class__.__name__} with add_prefix_space=True to use it with"
+ " pretokenized inputs."
+ )
+
+ return super()._encode_plus(*args, **kwargs)
+
+ def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]:
+ files = self._tokenizer.model.save(save_directory, name=filename_prefix)
+ return tuple(files)
+
+
+__all__ = ["BloomTokenizerFast"]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/cpmant/__init__.py b/vllm/lib/python3.10/site-packages/transformers/models/cpmant/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d92eea75693e728f4c1e9afc199d40751ef6af7a
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/cpmant/__init__.py
@@ -0,0 +1,28 @@
+# Copyright 2024 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import TYPE_CHECKING
+
+from ...utils import _LazyModule
+from ...utils.import_utils import define_import_structure
+
+
+if TYPE_CHECKING:
+ from .configuration_cpmant import *
+ from .modeling_cpmant import *
+ from .tokenization_cpmant import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/cpmant/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/cpmant/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0421f403a4bd44f4d7f8abfff2d84861fc327501
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/cpmant/__pycache__/__init__.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/cpmant/__pycache__/configuration_cpmant.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/cpmant/__pycache__/configuration_cpmant.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5bb66e6f991381172ceb0c4b7e7cbfaa9447c6bc
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/cpmant/__pycache__/configuration_cpmant.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/cpmant/__pycache__/modeling_cpmant.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/cpmant/__pycache__/modeling_cpmant.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..de60a066f3972667140ac0c5f04e9293a9739532
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/cpmant/__pycache__/modeling_cpmant.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/cpmant/__pycache__/tokenization_cpmant.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/cpmant/__pycache__/tokenization_cpmant.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8356598f7bb61a36cbdb1475aaa0e1c22657a3ae
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/cpmant/__pycache__/tokenization_cpmant.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/cpmant/modeling_cpmant.py b/vllm/lib/python3.10/site-packages/transformers/models/cpmant/modeling_cpmant.py
new file mode 100644
index 0000000000000000000000000000000000000000..df0aebe3cbf850d5ce022352c1f52e9b2d1f8d0e
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/cpmant/modeling_cpmant.py
@@ -0,0 +1,860 @@
+# coding=utf-8
+# Copyright 2022 The OpenBMB Team and The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""PyTorch CPMAnt"""
+
+import math
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint
+from torch import nn
+from torch.nn import CrossEntropyLoss
+
+from ...activations import ACT2FN
+from ...generation import GenerationMixin
+from ...modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast
+from ...modeling_utils import PreTrainedModel
+from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
+from .configuration_cpmant import CpmAntConfig
+
+
+logger = logging.get_logger(__name__)
+
+_CHECKPOINT_FOR_DOC = "openbmb/cpm-ant-10b"
+_CONFIG_FOR_DOC = "CpmAntConfig"
+
+
+class CpmAntLayerNorm(nn.Module):
+ """
+ We use Root Mean Square (RMS) Layer Normalization, please see https://arxiv.org/abs/1910.07467 for details."
+ """
+
+ def __init__(self, config: CpmAntConfig):
+ super().__init__()
+
+ self.eps = config.eps
+ self.dim_norm = config.hidden_size
+ self.weight = nn.Parameter(torch.empty(config.hidden_size))
+
+ def forward(self, hidden_states: torch.Tensor):
+ """
+ Args:
+ hidden_states (`torch.Tensor` of shape `(batch, seq_len, dim_in)`)
+ """
+ if hidden_states.size(-1) != self.dim_norm:
+ raise AssertionError("hidden_states.size(-1) != self.dim_norm")
+ old_dtype = hidden_states.dtype
+ variance = hidden_states.to(torch.float32).pow(2).mean(dim=-1, keepdim=True)
+ hidden_states = (hidden_states * torch.rsqrt(variance + self.eps)).to(old_dtype) * self.weight
+ return hidden_states
+
+
+class CpmAntAttention(nn.Module):
+ def __init__(self, config: CpmAntConfig):
+ super().__init__()
+ self.dim_model = config.hidden_size
+ self.num_heads = config.num_attention_heads
+ self.dim_head = config.dim_head
+
+ self.project_q = nn.Linear(self.dim_model, self.num_heads * self.dim_head, bias=False)
+ self.project_k = nn.Linear(self.dim_model, self.num_heads * self.dim_head, bias=False)
+ self.project_v = nn.Linear(self.dim_model, self.num_heads * self.dim_head, bias=False)
+
+ self.attention_out = nn.Linear(self.num_heads * self.dim_head, self.dim_model, bias=False)
+
+ self.softmax = torch.nn.Softmax(dim=-1)
+
+ if config.dropout_p is not None:
+ self.dropout = torch.nn.Dropout(p=config.dropout_p)
+ else:
+ self.dropout = None
+
+ def forward(
+ self,
+ hidden_q: torch.Tensor,
+ hidden_kv: torch.Tensor,
+ attention_mask: torch.BoolTensor,
+ position_bias: torch.Tensor,
+ output_attentions: Optional[bool] = False,
+ past_key_values: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+ use_cache: Optional[bool] = None,
+ ):
+ """
+ Args:
+ hidden_q (`torch.Tensor`):
+ Input of transformer block(self-attention block). It can be the raw embedding of a batch of sequences.
+ hidden_kv (`torch.Tensor` of shape `(batch, len_k, dim_model)`)):
+ Tensor *key_value* and *query* of shape `(batch, len_k, dim_model)`
+ attention_mask (`torch.Tensor` of shape `(batch, len_seq, len_seq)`):
+ Avoid invalid areas to participate in the calculation of self-attention.
+ position_bias (`torch.Tensor` of shape `(batch, len_seq, len_seq)`):
+ Provide positional information to self-attention block.
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers.
+ past_key_values (`Tuple[torch.Tensor, torch.Tensor]`, *optional*):
+ Cached past key and value projection states.
+ use_cache (`bool`, *optional*):
+ If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
+ (see `past_key_values`).
+ """
+ batch_size = hidden_q.size(0)
+ len_q = hidden_q.size(1)
+ len_k = hidden_kv.size(1)
+
+ query = self.project_q(hidden_q)
+ key = self.project_k(hidden_kv)
+ value = self.project_v(hidden_kv)
+
+ query = query.view(batch_size, len_q, self.num_heads, self.dim_head).permute(0, 2, 1, 3)
+ key = key.view(batch_size, len_k, self.num_heads, self.dim_head).permute(0, 2, 1, 3)
+ value = value.view(batch_size, len_k, self.num_heads, self.dim_head).permute(0, 2, 1, 3)
+
+ if past_key_values is not None:
+ key = torch.cat([past_key_values[0], key], dim=-2)
+ value = torch.cat([past_key_values[1], value], dim=-2)
+ len_k = key.size(-2)
+
+ # (batch_size, num_heads, len_q, dim_head) @ (batch_size, num_heads, dim_head, len_k) -> (batch_size, num_heads, len_q, len_k)
+ score = torch.matmul(query, key.transpose(-1, -2)) / math.sqrt(self.dim_head)
+ score = score + position_bias
+
+ score = torch.masked_fill(
+ score,
+ attention_mask.view(batch_size, 1, len_q, len_k) == torch.tensor(False),
+ torch.scalar_tensor(float("-inf"), device=score.device, dtype=score.dtype),
+ )
+ score = self.softmax(score)
+
+ score = torch.masked_fill(
+ score,
+ attention_mask.view(batch_size, 1, len_q, len_k) == torch.tensor(False),
+ torch.scalar_tensor(0, device=score.device, dtype=score.dtype),
+ )
+ if output_attentions:
+ attn_weights = score
+ else:
+ attn_weights = None
+
+ if self.dropout is not None:
+ score = self.dropout(score)
+
+ # (batch_size, num_heads, len_q, len_k) @ (batch_size, num_heads, len_k, dim_head) -> (batch_size, num_heads, len_q, dim_head)
+ score = torch.matmul(score, value)
+
+ score = score.view(batch_size, self.num_heads, len_q, self.dim_head).permute(0, 2, 1, 3)
+ score = score.contiguous().view(batch_size, len_q, self.num_heads * self.dim_head)
+
+ score = self.attention_out(score)
+
+ past_key_values = None
+ if use_cache:
+ past_key_values = (key, value)
+
+ return score, attn_weights, past_key_values
+
+
+class CpmAntSelfAttentionBlock(nn.Module):
+ def __init__(self, config: CpmAntConfig):
+ super().__init__()
+ self.layernorm_before_attention = CpmAntLayerNorm(config)
+ self.self_attention = CpmAntAttention(config)
+ if config.dropout_p:
+ self.dropout = torch.nn.Dropout(config.dropout_p)
+ else:
+ self.dropout = None
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor,
+ position_bias: Optional[torch.Tensor] = None,
+ output_attentions: Optional[bool] = False,
+ past_key_values: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+ use_cache: Optional[bool] = None,
+ ):
+ """
+ Args:
+ hidden_states (`torch.Tensor` of shape `(batch, len_seq, dim_model)`):
+ Input of transformer block(self-attention block). It can be the raw embedding of a batch of sequences.
+ attention_mask (`torch.Tensor` of shape `(batch, len_seq, len_seq)`):
+ Avoid invalid areas to participate in the calculation of self-attention.
+ position_bias (`torch.Tensor` of shape `(batch, len_seq, len_seq)`):
+ Provide positional information to self-attention block.
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers.
+ past_key_values (`Tuple(torch.FloatTensor)`, *optional*):
+ Cached past key and value projection states.
+ use_cache (`bool`, *optional*):
+ If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
+ (see `past_key_values`).
+ """
+ outputs = self.layernorm_before_attention(hidden_states)
+ outputs = self.self_attention(
+ outputs, outputs, attention_mask, position_bias, output_attentions, past_key_values, use_cache
+ )
+
+ outputs, attn_weights, current_key_value = outputs
+
+ if self.dropout is not None:
+ outputs = self.dropout(outputs)
+ hidden_states = hidden_states + outputs
+
+ return hidden_states, attn_weights, current_key_value
+
+
+class CpmAntDenseGatedACT(nn.Module):
+ def __init__(self, config: CpmAntConfig):
+ super().__init__()
+ self.w_0 = nn.Linear(config.hidden_size, config.dim_ff, bias=False)
+ self.w_1 = nn.Linear(config.hidden_size, config.dim_ff, bias=False)
+ self.act = torch.nn.GELU()
+
+ def forward(self, hidden_states: torch.Tensor):
+ """Transform an input tensor from one feature space to another via a nonlinear operation
+
+ Args:
+ hidden_states (`torch.Tensor` of shape `(batch, seq_len, dim_in)`)
+ """
+ gate_score = self.act(self.w_0(hidden_states))
+ hidden_states = self.w_1(hidden_states)
+
+ hidden_states = gate_score * hidden_states
+ return hidden_states
+
+
+class CpmAntFeedForward(nn.Module):
+ def __init__(self, config: CpmAntConfig):
+ super().__init__()
+ self.w_in = CpmAntDenseGatedACT(config)
+ if config.dropout_p is not None:
+ self.dropout = torch.nn.Dropout(config.dropout_p)
+ else:
+ self.dropout = None
+
+ self.w_out = nn.Linear(config.dim_ff, config.hidden_size, bias=False)
+
+ def forward(self, hidden_states: torch.Tensor):
+ """
+ Args:
+ hidden_states (`torch.Tensor` of shape `(batch, seq_len, dim_in)`)
+ """
+ hidden_states = self.w_in(hidden_states)
+
+ if self.dropout is not None:
+ hidden_states = self.dropout(hidden_states)
+
+ hidden_states = self.w_out(hidden_states)
+
+ return hidden_states
+
+
+class CpmAntFFNBlock(nn.Module):
+ def __init__(self, config: CpmAntConfig):
+ super().__init__()
+ self.layernorm_before_ffn = CpmAntLayerNorm(config)
+ self.ffn = CpmAntFeedForward(config)
+ if config.dropout_p:
+ self.dropout = torch.nn.Dropout(config.dropout_p)
+ else:
+ self.dropout = None
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ ):
+ """
+ Args:
+ hidden_states (`torch.Tensor` of shape `(batch, len_seq, dim_model)`):
+ Hidden states before feed forward layer.
+ """
+ ln_outputs = self.layernorm_before_ffn(hidden_states)
+ outputs = self.ffn(ln_outputs)
+ if self.dropout is not None:
+ outputs = self.dropout(outputs)
+ hidden_states = hidden_states + outputs
+ return hidden_states
+
+
+class CpmAntTransformerBlock(nn.Module):
+ def __init__(self, config: CpmAntConfig):
+ super().__init__()
+ self.self_att = CpmAntSelfAttentionBlock(config)
+ self.ffn = CpmAntFFNBlock(config)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor,
+ position_bias: Optional[torch.Tensor] = None,
+ output_attentions: Optional[bool] = False,
+ past_key_values: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+ use_cache: Optional[bool] = None,
+ ):
+ """
+ Args:
+ hidden_states (`torch.Tensor`):
+ Input to the layer of shape `(batch, seq_len, dim_model)`
+ attention_mask (`torch.Tensor`):
+ Avoid invalid areas to participate in the calculation of shape `(batch, seq_len, seq_len)`
+ position_bias (`torch.Tensor`):
+ Provides position information to attention mechanism of shape `(num_heads, seq_len, seq_len)`
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers.
+ past_key_values (`Tuple[torch.Tensor, torch.Tensor])`, *optional*):
+ Cached past key and value projection states
+ use_cache (`bool`, *optional*):
+ If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
+ (see `past_key_values`).
+ """
+ hidden_states = self.self_att(
+ hidden_states,
+ attention_mask=attention_mask,
+ position_bias=position_bias,
+ output_attentions=output_attentions,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ )
+
+ hidden_states, attn_weights, current_key_value = hidden_states
+
+ hidden_states = self.ffn(hidden_states)
+
+ return hidden_states, attn_weights, current_key_value
+
+
+class CpmAntEncoder(nn.Module):
+ def __init__(self, config: CpmAntConfig):
+ super().__init__()
+ self.num_layers = config.num_hidden_layers
+ self.layers = nn.ModuleList([CpmAntTransformerBlock(config) for ith in range(self.num_layers)])
+
+ self.output_layernorm = CpmAntLayerNorm(config)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor,
+ position_bias: torch.Tensor,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ past_key_values: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+ use_cache: Optional[bool] = None,
+ ):
+ """
+ Args:
+ hidden_states (`torch.Tensor`):
+ Input to the layer of shape `(batch, seq_len, dim_model)`
+ attention_mask (`torch.Tensor`):
+ Avoid invalid areas to participate in the calculation of shape `(batch, seq_len, seq_len)`
+ position_bias (`torch.Tensor`):
+ Provides position information to attention mechanism of shape `(num_heads, seq_len, seq_len)`
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers.
+ past_key_values (`Tuple[torch.Tensor, torch.Tensor])`, *optional*):
+ Cached past key and value projection states
+ use_cache (`bool`, *optional*):
+ If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
+ (see `past_key_values`).
+ """
+ all_hidden_states = () if output_hidden_states else None
+ all_self_attns = () if output_attentions else None
+ current_key_values = () if use_cache else None
+
+ for i, layer in enumerate(self.layers):
+ if output_hidden_states:
+ all_hidden_states += (hidden_states,)
+ layer_outputs = layer(
+ hidden_states,
+ attention_mask,
+ position_bias,
+ output_attentions=output_attentions,
+ past_key_values=past_key_values[i] if past_key_values else None,
+ use_cache=use_cache,
+ )
+ hidden_states, attn_weights, current_key_value = layer_outputs
+ if output_attentions:
+ all_self_attns += (attn_weights,)
+ if current_key_value is not None:
+ current_key_values = current_key_values + (current_key_value,)
+
+ hidden_states = self.output_layernorm(hidden_states)
+
+ if output_hidden_states:
+ all_hidden_states += (hidden_states,)
+
+ return hidden_states, current_key_values, all_hidden_states, all_self_attns
+
+
+# Copied from transformers.models.bert.modeling_bert.BertIntermediate with Bert->CPMAnt
+class CpmAntIntermediate(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
+ if isinstance(config.hidden_act, str):
+ self.intermediate_act_fn = ACT2FN[config.hidden_act]
+ else:
+ self.intermediate_act_fn = config.hidden_act
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.intermediate_act_fn(hidden_states)
+ return hidden_states
+
+
+class CpmAntSegmentPositionEmbedding(nn.Module):
+ def __init__(self, config: CpmAntConfig):
+ super().__init__()
+
+ self.num_heads = config.num_attention_heads
+ self.num_buckets = config.position_bias_num_buckets
+ self.max_distance = config.position_bias_max_distance
+ self.num_segments = config.segment_types
+
+ self.relative_attention_bias = nn.Parameter(
+ torch.empty(
+ config.segment_types * config.segment_types + config.position_bias_num_buckets,
+ config.num_attention_heads,
+ )
+ )
+
+ def forward(
+ self,
+ key_pos: torch.Tensor,
+ query_pos: torch.Tensor,
+ key_segment: torch.Tensor,
+ query_segment: torch.Tensor,
+ ):
+ with torch.no_grad():
+ batch = key_pos.size(0)
+ keylen = key_pos.size(1)
+ querylen = query_pos.size(1)
+
+ if key_pos.size(0) != query_pos.size(0):
+ raise AssertionError(
+ f"key_pos.size(0) should be equal to query_pos.size(0), but got {key_pos.size(0)} and {query_pos.size(0)}!"
+ )
+ if keylen != key_segment.size(1) or querylen != query_segment.size(1):
+ raise AssertionError(
+ f"keylen should be equal to key_segment.size(1), but got {keylen} and {key_segment.size(1)}!"
+ )
+ if querylen != query_segment.size(1):
+ raise AssertionError(
+ f"querylen should be equal to query_segment.size(1), but got {querylen} and {query_segment.szie(1)}!"
+ )
+
+ key_pos = key_pos.view(batch, -1, keylen)
+ query_pos = query_pos.view(batch, querylen, -1)
+ key_segment = key_segment.view(batch, -1, keylen)
+ query_segment = query_segment.view(batch, querylen, -1)
+
+ relative_position_bucket = self._segment_relative_position_bucket(query_segment, key_segment)
+ relative_position_bucket = relative_position_bucket + self.num_buckets
+
+ # (batch, len_q, len_k)
+ absolute_position_bucket = self._position_bucket(
+ torch.arange(keylen, dtype=torch.int32, device=relative_position_bucket.device)[None, :]
+ - torch.arange(querylen, dtype=torch.int32, device=relative_position_bucket.device)[:, None],
+ num_buckets=self.num_buckets,
+ max_distance=self.max_distance,
+ )
+ relative_position_bucket = torch.where(
+ (key_segment == query_segment),
+ absolute_position_bucket[None, :, :],
+ relative_position_bucket,
+ )
+
+ # (batch, len_q, len_k, num_heads)
+ embeds = F.embedding(relative_position_bucket, self.relative_attention_bias)
+ # (batch, num_heads, len_q, len_k)
+ embeds = embeds.permute(0, 3, 1, 2).contiguous()
+ return embeds
+
+ def _segment_relative_position_bucket(self, query_segment, key_segment):
+ return query_segment * self.num_segments + key_segment
+
+ def _position_bucket(self, relative_position, num_buckets=32, max_distance=128):
+ relative_buckets = 0
+ # always bidirectional in CPMAnt
+ num_buckets //= 2
+ relative_buckets = (relative_position > 0).to(torch.int32) * num_buckets
+ relative_position = torch.abs(relative_position)
+ max_exact = num_buckets // 2
+ is_small = relative_position < max_exact
+ relative_postion_if_large = max_exact + (
+ torch.log(relative_position.float() / max_exact)
+ / math.log(max_distance / max_exact)
+ * (num_buckets - max_exact)
+ ).to(torch.int32)
+ relative_postion_if_large = torch.min(
+ relative_postion_if_large,
+ torch.full_like(relative_postion_if_large, num_buckets - 1),
+ )
+ relative_buckets += torch.where(is_small, relative_position.to(torch.int32), relative_postion_if_large)
+ return relative_buckets
+
+
+# Copied from transformers.models.bert.modeling_bert.BertOutput with Bert->CPMAnt
+class CpmAntOutput(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
+ self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+ def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = self.LayerNorm(hidden_states + input_tensor)
+ return hidden_states
+
+
+class CpmAntPreTrainedModel(PreTrainedModel):
+ """
+ An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+ models.
+ """
+
+ config_class = CpmAntConfig
+ base_model_prefix = "cpmant"
+
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ if isinstance(module, nn.Linear):
+ module.weight.data.normal_(mean=0.0, std=self.config.init_std)
+ if module.bias is not None:
+ module.bias.data.zero_()
+ elif isinstance(module, nn.Embedding):
+ module.weight.data.normal_(mean=0.0, std=self.config.init_std)
+ if module.padding_idx is not None:
+ module.weight.data[module.padding_idx].zero_()
+ elif isinstance(module, nn.LayerNorm):
+ module.bias.data.zero_()
+ module.weight.data.fill_(1.0)
+ elif isinstance(module, CpmAntLayerNorm):
+ module.weight.data.fill_(1.0)
+ elif isinstance(module, CpmAntSegmentPositionEmbedding):
+ module.relative_attention_bias.data.normal_(mean=0.0, std=self.config.init_std)
+
+
+CPMANT_START_DOCSTRING = r"""
+ This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) sub-class. Use
+ it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
+ behavior.
+
+ Parameters
+ config ([`~CpmAntConfig`]): Model configuration class with all the parameters of the
+ Initializing with a config file does not load the weights associated with the model, only the
+ configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+"""
+
+CPMANT_INPUTS_DOCSTRING = r"""
+ Args:
+ input_ids (`torch.Tensor` of shape `(batch_size, seq_len)`):
+ Indices of input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`CPMAntTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are input IDs?](../glossary#input-ids)
+ past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
+ Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
+ blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.
+ use_cache (`bool`, *optional*):
+ If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
+ `past_key_values`).
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers.
+ return_dict (`bool`, *optional*):
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+"""
+
+
+@add_start_docstrings(
+ "The bare CPMAnt Model outputting raw hidden-states without any specific head on top.",
+ CPMANT_START_DOCSTRING,
+)
+class CpmAntModel(CpmAntPreTrainedModel):
+ def __init__(self, config: CpmAntConfig):
+ super().__init__(config)
+ self.encoder = CpmAntEncoder(config)
+ self.segment_embedding = nn.Embedding(config.segment_types, config.hidden_size)
+ self.input_embedding = nn.Embedding(
+ config.vocab_size + config.prompt_types * config.prompt_length, config.hidden_size
+ )
+ self.position_bias = CpmAntSegmentPositionEmbedding(config)
+ self.prompt_length = config.prompt_length
+ self.vocab_size = config.vocab_size
+
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.input_embedding
+
+ def set_input_embeddings(self, embeddings, **kwargs):
+ self.input_embedding = embeddings
+
+ def _prepare_attention_mask(self, input_ids, span, context, length):
+ batch = input_ids.size(0)
+ seqlen = input_ids.size(1)
+ device = input_ids.device
+ directional_mask_2d = torch.arange(seqlen, device=device) <= torch.arange(seqlen, device=device).view(-1, 1)
+ attention_mask = context[:, None, :] | (
+ context[:, :, None].logical_not() & directional_mask_2d.view(1, seqlen, seqlen)
+ )
+ attention_mask = attention_mask & (span[:, None, :] == span[:, :, None])
+ # mask for left padding
+ mask_1d = (
+ torch.tensor(list(range(seqlen - self.prompt_length))[::-1], device=device)[None, :].repeat(batch, 1)
+ < length[:, None]
+ )
+ mask_1d = torch.cat((torch.ones(batch, self.prompt_length, device=device).bool(), mask_1d), dim=1)
+ attention_mask = mask_1d.view(batch, seqlen, 1) & mask_1d.view(batch, 1, seqlen) & attention_mask
+ return attention_mask
+
+ @add_start_docstrings_to_model_forward(CPMANT_INPUTS_DOCSTRING)
+ @add_code_sample_docstrings(
+ checkpoint=_CHECKPOINT_FOR_DOC,
+ output_type=BaseModelOutputWithPast,
+ config_class=_CONFIG_FOR_DOC,
+ )
+ def forward(
+ self,
+ input_ids: Optional[torch.Tensor] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None,
+ use_cache: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ **kwargs,
+ ) -> Union[Tuple[torch.Tensor], BaseModelOutputWithPast]:
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+
+ # add prompts ahead
+ if input_ids.dtype != torch.int32:
+ input_ids = input_ids.to(torch.int32)
+ dtype, device = input_ids.dtype, input_ids.device
+ segment = torch.where(input_ids != 0, 2, 0).to(dtype=dtype, device=device)
+ length = (segment != 0).sum(-1).to(dtype=dtype, device=device)
+ input_ids = torch.cat(
+ (
+ torch.arange(
+ self.prompt_length * 2 + self.vocab_size,
+ self.prompt_length * 3 + self.vocab_size,
+ dtype=dtype,
+ device=device,
+ ).repeat(input_ids.size(0), 1),
+ input_ids,
+ ),
+ dim=1,
+ )
+ batch, seq_length = input_ids.size()
+ segment = torch.cat((torch.zeros(batch, self.prompt_length, dtype=dtype, device=device), segment), dim=1)
+ context = torch.full((batch, seq_length), 1, dtype=dtype, device=device)
+ position = torch.arange(seq_length, dtype=dtype, device=device).repeat(batch, 1)
+ span = torch.full((batch, seq_length), 0, dtype=dtype, device=device)
+
+ if past_key_values is None:
+ past_length = 0
+ past_key_values = tuple([None] * self.encoder.num_layers)
+ input_ids = input_ids.contiguous()
+ hidden_states = self.input_embedding(input_ids)
+ segment_states = self.segment_embedding(segment)
+ hidden_states = hidden_states + segment_states
+ else:
+ past_length = past_key_values[0][0].size(-2)
+ segment_states = self.segment_embedding(segment)
+ hidden_states = self.input_embedding(input_ids) + segment_states[:, -1:, :]
+
+ attention_mask = self._prepare_attention_mask(input_ids, span, context, length)
+ position_bias = self.position_bias(position, position, segment, segment)
+
+ attention_mask = attention_mask[:, past_length:, :]
+ position_bias = position_bias[:, :, past_length:, :]
+ hidden_states = hidden_states[:, past_length:, :]
+
+ hidden_states, present_key_values, all_hidden_states, all_attentions = self.encoder(
+ hidden_states,
+ attention_mask,
+ position_bias,
+ output_attentions,
+ output_hidden_states,
+ past_key_values,
+ use_cache,
+ )
+
+ if past_length == 0:
+ hidden_states = hidden_states[:, self.prompt_length :, :]
+ # drop the prompt
+ if all_attentions is not None:
+ new_attentions = ()
+ for attention in all_attentions:
+ new_attentions += (attention[:, :, self.prompt_length :, self.prompt_length :],)
+ all_attentions = new_attentions
+ if all_hidden_states is not None:
+ new_hidden_states = ()
+ for hidden_state in all_hidden_states:
+ new_hidden_states += (hidden_state[:, self.prompt_length :, :],)
+ all_hidden_states = new_hidden_states
+
+ if not return_dict:
+ return tuple(
+ v for v in [hidden_states, present_key_values, all_hidden_states, all_attentions] if v is not None
+ )
+
+ return BaseModelOutputWithPast(
+ last_hidden_state=hidden_states,
+ past_key_values=present_key_values,
+ hidden_states=all_hidden_states,
+ attentions=all_attentions,
+ )
+
+
+@add_start_docstrings(
+ """
+ The CPMAnt Model with a language modeling head on top (linear layer with weights tied to the input embeddings).
+ """,
+ CPMANT_START_DOCSTRING,
+)
+class CpmAntForCausalLM(CpmAntPreTrainedModel, GenerationMixin):
+ _tied_weights_keys = ["lm_head.weight"]
+
+ def __init__(self, config: CpmAntConfig):
+ super().__init__(config)
+ self.cpmant = CpmAntModel(config)
+
+ # lm_head.weight is tied to cpmant.input_embedding.weight
+ self.lm_head = nn.Linear(
+ config.hidden_size, config.vocab_size + config.prompt_types * config.prompt_length, bias=False
+ )
+ self.post_init()
+
+ @add_start_docstrings_to_model_forward(CPMANT_INPUTS_DOCSTRING)
+ @add_code_sample_docstrings(
+ checkpoint=_CHECKPOINT_FOR_DOC,
+ output_type=CausalLMOutputWithPast,
+ config_class=_CONFIG_FOR_DOC,
+ )
+ def forward(
+ self,
+ input_ids: Optional[torch.Tensor] = None,
+ past_key_values: Optional[List[Tuple[torch.Tensor, torch.Tensor]]] = None,
+ use_cache: Optional[bool] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ labels: Optional[torch.Tensor] = None,
+ return_dict: Optional[bool] = None,
+ attention_mask: Optional[torch.Tensor] = None, # dummy parameter for text-generation pipeline
+ **kwargs,
+ ) -> Union[Tuple, CausalLMOutputWithPast]:
+ r"""
+ Args:
+ input_ids (`torch.Tensor` of shape `(batch_size, seq_len)`):
+ Indices of input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`CPMAntTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are input IDs?](../glossary#input-ids)
+ past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
+ Contains pre-computed hidden-states (key and values in the self-attention blocks and in the
+ cross-attention blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.
+ use_cache (`bool`, *optional*):
+ If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
+ (see `past_key_values`).
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers.
+ labels (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the masked language modeling loss.
+ return_dict (`bool`, *optional*):
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+ attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+ CPMAnt will process attention mask automatically, this parameter is a dummy parameter for
+ text-generation pipeline.
+
+ Example:
+
+ Text Generation with CpmAntForCausalLM.
+ ```python
+ >>> from transformers import CPMAntTokenizer, CpmAntForCausalLM
+
+ >>> texts = "今天天气不错,"
+ >>> model = CpmAntForCausalLM.from_pretrained("openbmb/cpm-ant-10b")
+ >>> tokenizer = CPMAntTokenizer.from_pretrained("openbmb/cpm-ant-10b")
+ >>> input_ids = tokenizer(texts, return_tensors="pt")
+ >>> outputs = model.generate(**input_ids)
+ >>> output_texts = tokenizer.batch_decode(outputs)
+ >>> print(output_texts)
+ ['今天天气不错,阳光明媚,我和妈妈一起去超市买东西。\n在超市里,我看到了一个很好玩的玩具,它的名字叫“机器人”。它有一个圆圆的脑袋,两只圆圆的眼睛,还有一个圆圆的']
+ ```
+ """
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+ model_output = self.cpmant(
+ input_ids, output_attentions, output_hidden_states, past_key_values, use_cache, return_dict
+ )
+ hidden_states = model_output.last_hidden_state if return_dict else model_output[0]
+
+ logits = self.lm_head(hidden_states)
+
+ loss = None
+ if labels is not None:
+ loss_func = CrossEntropyLoss()
+ loss = loss_func(logits.view(-1, logits.size(-1)), labels.view(-1))
+
+ if not return_dict:
+ output = (logits,) + model_output[1:]
+ return ((loss,) + output) if loss is not None else output
+
+ return CausalLMOutputWithPast(
+ loss=loss,
+ logits=logits,
+ past_key_values=model_output.past_key_values,
+ hidden_states=model_output.hidden_states,
+ attentions=model_output.attentions,
+ )
+
+ def get_input_embeddings(self):
+ return self.cpmant.input_embedding
+
+ def set_input_embeddings(self, embeddings):
+ self.cpmant.input_embedding = embeddings
+
+ def get_output_embeddings(self):
+ return self.lm_head
+
+ def set_output_embeddings(self, new_embeddings):
+ self.lm_head = new_embeddings
+
+ def _reorder_cache(self, past_key_values, beam_idx):
+ past_key_values = [list(each) if each is not None else each for each in past_key_values]
+ for key_value_layer in past_key_values:
+ key_value_layer[0] = key_value_layer[0][beam_idx]
+ key_value_layer[1] = key_value_layer[1][beam_idx]
+ return past_key_values
+
+
+__all__ = ["CpmAntForCausalLM", "CpmAntModel", "CpmAntPreTrainedModel"]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/cpmant/tokenization_cpmant.py b/vllm/lib/python3.10/site-packages/transformers/models/cpmant/tokenization_cpmant.py
new file mode 100644
index 0000000000000000000000000000000000000000..2da1d6286c5e8b3a39750ae705cc1486ddd63416
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/cpmant/tokenization_cpmant.py
@@ -0,0 +1,270 @@
+# coding=utf-8
+# Copyright 2022 The OpenBMB Team and The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tokenization classes for CPMAnt."""
+
+import collections
+import os
+from typing import List, Optional, Tuple
+
+from transformers.utils import is_jieba_available, requires_backends
+
+
+if is_jieba_available():
+ import jieba
+
+from ...tokenization_utils import PreTrainedTokenizer
+from ...utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+VOCAB_FILES_NAMES = {"vocab_file": "vocab.txt"}
+
+
+def load_vocab(vocab_file):
+ """Loads a vocabulary file into a dictionary."""
+ vocab = collections.OrderedDict()
+ with open(vocab_file, "r", encoding="utf-8") as reader:
+ tokens = reader.readlines()
+ for index, token in enumerate(tokens):
+ token = token.rstrip("\n")
+ vocab[token] = index
+ return vocab
+
+
+class WordpieceTokenizer:
+ def __init__(self, vocab, unk_token="", max_input_chars_per_word=200):
+ self.vocab = vocab
+ self.unk_token = unk_token
+ self.max_input_chars_per_word = max_input_chars_per_word
+
+ def tokenize(self, token):
+ chars = list(token)
+ if len(chars) > self.max_input_chars_per_word:
+ return [self.unk_token]
+
+ start = 0
+ sub_tokens = []
+ while start < len(chars):
+ end = len(chars)
+ cur_substr = None
+ while start < end:
+ substr = "".join(chars[start:end])
+ if substr in self.vocab:
+ cur_substr = substr
+ break
+ end -= 1
+ if cur_substr is None:
+ sub_tokens.append(self.unk_token)
+ start += 1
+ else:
+ sub_tokens.append(cur_substr)
+ start = end
+
+ return sub_tokens
+
+
+class CpmAntTokenizer(PreTrainedTokenizer):
+ """
+ Construct a CPMAnt tokenizer. Based on byte-level Byte-Pair-Encoding.
+
+ Args:
+ vocab_file (`str`):
+ Path to the vocabulary file.
+ bod_token (`str`, *optional*, defaults to `""`):
+ The beginning of document token.
+ eod_token (`str`, *optional*, defaults to `""`):
+ The end of document token.
+ bos_token (`str`, *optional*, defaults to `""`):
+ The beginning of sequence token.
+ eos_token (`str`, *optional*, defaults to `""`):
+ The end of sequence token.
+ pad_token (`str`, *optional*, defaults to `""`):
+ The token used for padding.
+ unk_token (`str`, *optional*, defaults to `""`):
+ The unknown token.
+ line_token (`str`, *optional*, defaults to `""`):
+ The line token.
+ space_token (`str`, *optional*, defaults to `""`):
+ The space token.
+ """
+
+ vocab_files_names = VOCAB_FILES_NAMES
+ model_input_names = ["input_ids", "attention_mask"]
+ add_prefix_space = False
+
+ def __init__(
+ self,
+ vocab_file,
+ bod_token="",
+ eod_token="",
+ bos_token="",
+ eos_token="",
+ pad_token="",
+ unk_token="",
+ line_token="",
+ space_token="",
+ padding_side="left",
+ **kwargs,
+ ):
+ requires_backends(self, ["jieba"])
+ self.bod_token = bod_token
+ self.eod_token = eod_token
+ self.encoder = load_vocab(vocab_file)
+ self.encoder[" "] = self.encoder[space_token]
+ self.encoder["\n"] = self.encoder[line_token]
+
+ del self.encoder[space_token]
+ del self.encoder[line_token]
+
+ self.encoder = collections.OrderedDict(sorted(self.encoder.items(), key=lambda x: x[1]))
+ self.decoder = {v: k for k, v in self.encoder.items()}
+
+ self.wordpiece_tokenizer = WordpieceTokenizer(vocab=self.encoder, unk_token=unk_token)
+
+ super().__init__(
+ bod_token=bod_token,
+ eod_token=eod_token,
+ bos_token=bos_token,
+ eos_token=eos_token,
+ pad_token=pad_token,
+ unk_token=unk_token,
+ line_token=line_token,
+ space_token=space_token,
+ padding_side=padding_side,
+ **kwargs,
+ )
+
+ @property
+ def bod_token_id(self):
+ return self.encoder[self.bod_token]
+
+ @property
+ def eod_token_id(self):
+ return self.encoder[self.eod_token]
+
+ @property
+ def newline_id(self):
+ return self.encoder["\n"]
+
+ @property
+ def vocab_size(self) -> int:
+ return len(self.encoder)
+
+ def get_vocab(self):
+ return dict(self.encoder, **self.added_tokens_encoder)
+
+ def _tokenize(self, text):
+ """Tokenize a string."""
+ output_tokens = []
+ for x in jieba.cut(text, cut_all=False):
+ output_tokens.extend(self.wordpiece_tokenizer.tokenize(x))
+ return output_tokens
+
+ def _decode(self, token_ids, **kwargs):
+ """Decode ids into a string."""
+ token_ids = [i for i in token_ids if i >= 0]
+ token_ids = [
+ x for x in token_ids if x != self.pad_token_id and x != self.eos_token_id and x != self.bos_token_id
+ ]
+ return super()._decode(token_ids, **kwargs)
+
+ def check(self, token):
+ return token in self.encoder
+
+ def convert_tokens_to_string(self, tokens: List[str]) -> str:
+ return "".join(tokens)
+
+ def _convert_token_to_id(self, token):
+ """Converts a token (str) in an id using the vocab."""
+ return self.encoder.get(token, self.encoder.get(self.unk_token))
+
+ def _convert_id_to_token(self, index):
+ """Converts an index (integer) in a token (str) using the vocab."""
+ return self.decoder.get(index, self.unk_token)
+
+ def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]:
+ if os.path.isdir(save_directory):
+ vocab_file = os.path.join(
+ save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]
+ )
+ else:
+ vocab_file = (filename_prefix + "-" if filename_prefix else "") + save_directory
+ index = 0
+ if " " in self.encoder:
+ self.encoder[""] = self.encoder[" "]
+ del self.encoder[" "]
+ if "\n" in self.encoder:
+ self.encoder[""] = self.encoder["\n"]
+ del self.encoder["\n"]
+ self.encoder = collections.OrderedDict(sorted(self.encoder.items(), key=lambda x: x[1]))
+ with open(vocab_file, "w", encoding="utf-8") as writer:
+ for token, token_index in self.encoder.items():
+ if index != token_index:
+ logger.warning(
+ f"Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive."
+ " Please check that the vocabulary is not corrupted!"
+ )
+ index = token_index
+ writer.write(token + "\n")
+ index += 1
+ return (vocab_file,)
+
+ def build_inputs_with_special_tokens(self, token_ids_0: List[int], token_ids_1: List[int] = None) -> List[int]:
+ """
+ Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and
+ adding special tokens. A CPMAnt sequence has the following format:
+
+ - single sequence: `[BOS] Sequence`.
+
+ Args:
+ token_ids_0 (`List[int]`): The first tokenized sequence that special tokens will be added.
+ token_ids_1 (`List[int]`): The optional second tokenized sequence that special tokens will be added.
+
+ Returns:
+ `List[int]`: The model input with special tokens.
+ """
+ if token_ids_1 is None:
+ return [self.bos_token_id] + token_ids_0
+ return [self.bos_token_id] + token_ids_0 + [self.bos_token_id] + token_ids_1
+
+ def get_special_tokens_mask(
+ self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None, already_has_special_tokens: bool = False
+ ) -> List[int]:
+ """
+ Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding
+ special tokens using the tokenizer `prepare_for_model` method.
+
+ Args:
+ token_ids_0 (`List[int]`): List of IDs.
+ token_ids_1 (`List[int]`, *optional*): Optional second list of IDs for sequence pairs.
+ already_has_special_tokens (`bool`, *optional*, defaults to `False`):
+ Whether or not the token list is already formatted with special tokens for the model.
+
+ Returns:
+ `List[int]`: A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token.
+ """
+
+ if already_has_special_tokens:
+ return super().get_special_tokens_mask(
+ token_ids_0=token_ids_0, token_ids_1=token_ids_1, already_has_special_tokens=True
+ )
+
+ if token_ids_1 is not None:
+ return [1] + ([0] * len(token_ids_0)) + [1] + ([0] * len(token_ids_1))
+ return [1] + ([0] * len(token_ids_0))
+
+
+__all__ = ["CpmAntTokenizer"]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__init__.py b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..16a1959c30ff5474ed82a6b0a2e22896514d6a44
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__init__.py
@@ -0,0 +1,32 @@
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from typing import TYPE_CHECKING
+
+from ...utils import _LazyModule
+from ...utils.import_utils import define_import_structure
+
+
+if TYPE_CHECKING:
+ from .configuration_deformable_detr import *
+ from .feature_extraction_deformable_detr import *
+ from .image_processing_deformable_detr import *
+ from .image_processing_deformable_detr_fast import *
+ from .modeling_deformable_detr import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2e575ea7dfc0f6b91e9b6213fd8733a5b4dbb05e
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/__init__.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/configuration_deformable_detr.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/configuration_deformable_detr.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b2347fea5490cadf82cdac67a0160b6469ab06fc
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/configuration_deformable_detr.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/feature_extraction_deformable_detr.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/feature_extraction_deformable_detr.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9c6c5f4623ed15fa61a0062aa218dec16b2a590b
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/feature_extraction_deformable_detr.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/image_processing_deformable_detr.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/image_processing_deformable_detr.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..73b90cbcfaa72cc5076811eca565c1a461f6b4f4
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/image_processing_deformable_detr.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/image_processing_deformable_detr_fast.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/image_processing_deformable_detr_fast.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d636ad94e27369893e25486cbf0199f9fdb3259e
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/image_processing_deformable_detr_fast.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/modeling_deformable_detr.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/modeling_deformable_detr.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..11729f3e13ba2f189e019e383902f1c7a7f86aee
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/modeling_deformable_detr.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/modular_deformable_detr.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/modular_deformable_detr.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..572e72ceb91c85d77f3b30421e667f8dacd8c766
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/__pycache__/modular_deformable_detr.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/configuration_deformable_detr.py b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/configuration_deformable_detr.py
new file mode 100644
index 0000000000000000000000000000000000000000..05bd0f906a110820c36f12fb75b73c1fd0927006
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/configuration_deformable_detr.py
@@ -0,0 +1,282 @@
+# coding=utf-8
+# Copyright 2022 SenseTime and The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Deformable DETR model configuration"""
+
+from ...configuration_utils import PretrainedConfig
+from ...utils import logging
+from ...utils.backbone_utils import verify_backbone_config_arguments
+from ..auto import CONFIG_MAPPING
+
+
+logger = logging.get_logger(__name__)
+
+
+class DeformableDetrConfig(PretrainedConfig):
+ r"""
+ This is the configuration class to store the configuration of a [`DeformableDetrModel`]. It is used to instantiate
+ a Deformable DETR model according to the specified arguments, defining the model architecture. Instantiating a
+ configuration with the defaults will yield a similar configuration to that of the Deformable DETR
+ [SenseTime/deformable-detr](https://huggingface.co/SenseTime/deformable-detr) architecture.
+
+ Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+ documentation from [`PretrainedConfig`] for more information.
+
+ Args:
+ use_timm_backbone (`bool`, *optional*, defaults to `True`):
+ Whether or not to use the `timm` library for the backbone. If set to `False`, will use the [`AutoBackbone`]
+ API.
+ backbone_config (`PretrainedConfig` or `dict`, *optional*):
+ The configuration of the backbone model. Only used in case `use_timm_backbone` is set to `False` in which
+ case it will default to `ResNetConfig()`.
+ num_channels (`int`, *optional*, defaults to 3):
+ The number of input channels.
+ num_queries (`int`, *optional*, defaults to 300):
+ Number of object queries, i.e. detection slots. This is the maximal number of objects
+ [`DeformableDetrModel`] can detect in a single image. In case `two_stage` is set to `True`, we use
+ `two_stage_num_proposals` instead.
+ d_model (`int`, *optional*, defaults to 256):
+ Dimension of the layers.
+ encoder_layers (`int`, *optional*, defaults to 6):
+ Number of encoder layers.
+ decoder_layers (`int`, *optional*, defaults to 6):
+ Number of decoder layers.
+ encoder_attention_heads (`int`, *optional*, defaults to 8):
+ Number of attention heads for each attention layer in the Transformer encoder.
+ decoder_attention_heads (`int`, *optional*, defaults to 8):
+ Number of attention heads for each attention layer in the Transformer decoder.
+ decoder_ffn_dim (`int`, *optional*, defaults to 1024):
+ Dimension of the "intermediate" (often named feed-forward) layer in decoder.
+ encoder_ffn_dim (`int`, *optional*, defaults to 1024):
+ Dimension of the "intermediate" (often named feed-forward) layer in decoder.
+ activation_function (`str` or `function`, *optional*, defaults to `"relu"`):
+ The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
+ `"relu"`, `"silu"` and `"gelu_new"` are supported.
+ dropout (`float`, *optional*, defaults to 0.1):
+ The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
+ attention_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout ratio for the attention probabilities.
+ activation_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout ratio for activations inside the fully connected layer.
+ init_std (`float`, *optional*, defaults to 0.02):
+ The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+ init_xavier_std (`float`, *optional*, defaults to 1):
+ The scaling factor used for the Xavier initialization gain in the HM Attention map module.
+ encoder_layerdrop (`float`, *optional*, defaults to 0.0):
+ The LayerDrop probability for the encoder. See the [LayerDrop paper](see https://arxiv.org/abs/1909.11556)
+ for more details.
+ auxiliary_loss (`bool`, *optional*, defaults to `False`):
+ Whether auxiliary decoding losses (loss at each decoder layer) are to be used.
+ position_embedding_type (`str`, *optional*, defaults to `"sine"`):
+ Type of position embeddings to be used on top of the image features. One of `"sine"` or `"learned"`.
+ backbone (`str`, *optional*, defaults to `"resnet50"`):
+ Name of backbone to use when `backbone_config` is `None`. If `use_pretrained_backbone` is `True`, this
+ will load the corresponding pretrained weights from the timm or transformers library. If `use_pretrained_backbone`
+ is `False`, this loads the backbone's config and uses that to initialize the backbone with random weights.
+ use_pretrained_backbone (`bool`, *optional*, defaults to `True`):
+ Whether to use pretrained weights for the backbone.
+ backbone_kwargs (`dict`, *optional*):
+ Keyword arguments to be passed to AutoBackbone when loading from a checkpoint
+ e.g. `{'out_indices': (0, 1, 2, 3)}`. Cannot be specified if `backbone_config` is set.
+ dilation (`bool`, *optional*, defaults to `False`):
+ Whether to replace stride with dilation in the last convolutional block (DC5). Only supported when
+ `use_timm_backbone` = `True`.
+ class_cost (`float`, *optional*, defaults to 1):
+ Relative weight of the classification error in the Hungarian matching cost.
+ bbox_cost (`float`, *optional*, defaults to 5):
+ Relative weight of the L1 error of the bounding box coordinates in the Hungarian matching cost.
+ giou_cost (`float`, *optional*, defaults to 2):
+ Relative weight of the generalized IoU loss of the bounding box in the Hungarian matching cost.
+ mask_loss_coefficient (`float`, *optional*, defaults to 1):
+ Relative weight of the Focal loss in the panoptic segmentation loss.
+ dice_loss_coefficient (`float`, *optional*, defaults to 1):
+ Relative weight of the DICE/F-1 loss in the panoptic segmentation loss.
+ bbox_loss_coefficient (`float`, *optional*, defaults to 5):
+ Relative weight of the L1 bounding box loss in the object detection loss.
+ giou_loss_coefficient (`float`, *optional*, defaults to 2):
+ Relative weight of the generalized IoU loss in the object detection loss.
+ eos_coefficient (`float`, *optional*, defaults to 0.1):
+ Relative classification weight of the 'no-object' class in the object detection loss.
+ num_feature_levels (`int`, *optional*, defaults to 4):
+ The number of input feature levels.
+ encoder_n_points (`int`, *optional*, defaults to 4):
+ The number of sampled keys in each feature level for each attention head in the encoder.
+ decoder_n_points (`int`, *optional*, defaults to 4):
+ The number of sampled keys in each feature level for each attention head in the decoder.
+ two_stage (`bool`, *optional*, defaults to `False`):
+ Whether to apply a two-stage deformable DETR, where the region proposals are also generated by a variant of
+ Deformable DETR, which are further fed into the decoder for iterative bounding box refinement.
+ two_stage_num_proposals (`int`, *optional*, defaults to 300):
+ The number of region proposals to be generated, in case `two_stage` is set to `True`.
+ with_box_refine (`bool`, *optional*, defaults to `False`):
+ Whether to apply iterative bounding box refinement, where each decoder layer refines the bounding boxes
+ based on the predictions from the previous layer.
+ focal_alpha (`float`, *optional*, defaults to 0.25):
+ Alpha parameter in the focal loss.
+ disable_custom_kernels (`bool`, *optional*, defaults to `False`):
+ Disable the use of custom CUDA and CPU kernels. This option is necessary for the ONNX export, as custom
+ kernels are not supported by PyTorch ONNX export.
+
+ Examples:
+
+ ```python
+ >>> from transformers import DeformableDetrConfig, DeformableDetrModel
+
+ >>> # Initializing a Deformable DETR SenseTime/deformable-detr style configuration
+ >>> configuration = DeformableDetrConfig()
+
+ >>> # Initializing a model (with random weights) from the SenseTime/deformable-detr style configuration
+ >>> model = DeformableDetrModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "deformable_detr"
+ attribute_map = {
+ "hidden_size": "d_model",
+ "num_attention_heads": "encoder_attention_heads",
+ }
+
+ def __init__(
+ self,
+ use_timm_backbone=True,
+ backbone_config=None,
+ num_channels=3,
+ num_queries=300,
+ max_position_embeddings=1024,
+ encoder_layers=6,
+ encoder_ffn_dim=1024,
+ encoder_attention_heads=8,
+ decoder_layers=6,
+ decoder_ffn_dim=1024,
+ decoder_attention_heads=8,
+ encoder_layerdrop=0.0,
+ is_encoder_decoder=True,
+ activation_function="relu",
+ d_model=256,
+ dropout=0.1,
+ attention_dropout=0.0,
+ activation_dropout=0.0,
+ init_std=0.02,
+ init_xavier_std=1.0,
+ return_intermediate=True,
+ auxiliary_loss=False,
+ position_embedding_type="sine",
+ backbone="resnet50",
+ use_pretrained_backbone=True,
+ backbone_kwargs=None,
+ dilation=False,
+ num_feature_levels=4,
+ encoder_n_points=4,
+ decoder_n_points=4,
+ two_stage=False,
+ two_stage_num_proposals=300,
+ with_box_refine=False,
+ class_cost=1,
+ bbox_cost=5,
+ giou_cost=2,
+ mask_loss_coefficient=1,
+ dice_loss_coefficient=1,
+ bbox_loss_coefficient=5,
+ giou_loss_coefficient=2,
+ eos_coefficient=0.1,
+ focal_alpha=0.25,
+ disable_custom_kernels=False,
+ **kwargs,
+ ):
+ # We default to values which were previously hard-coded in the model. This enables configurability of the config
+ # while keeping the default behavior the same.
+ if use_timm_backbone and backbone_kwargs is None:
+ backbone_kwargs = {}
+ if dilation:
+ backbone_kwargs["output_stride"] = 16
+ backbone_kwargs["out_indices"] = [2, 3, 4] if num_feature_levels > 1 else [4]
+ backbone_kwargs["in_chans"] = num_channels
+ # Backwards compatibility
+ elif not use_timm_backbone and backbone in (None, "resnet50"):
+ if backbone_config is None:
+ logger.info("`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.")
+ backbone_config = CONFIG_MAPPING["resnet"](out_features=["stage4"])
+ elif isinstance(backbone_config, dict):
+ backbone_model_type = backbone_config.get("model_type")
+ config_class = CONFIG_MAPPING[backbone_model_type]
+ backbone_config = config_class.from_dict(backbone_config)
+
+ verify_backbone_config_arguments(
+ use_timm_backbone=use_timm_backbone,
+ use_pretrained_backbone=use_pretrained_backbone,
+ backbone=backbone,
+ backbone_config=backbone_config,
+ backbone_kwargs=backbone_kwargs,
+ )
+
+ self.use_timm_backbone = use_timm_backbone
+ self.backbone_config = backbone_config
+ self.num_channels = num_channels
+ self.num_queries = num_queries
+ self.max_position_embeddings = max_position_embeddings
+ self.d_model = d_model
+ self.encoder_ffn_dim = encoder_ffn_dim
+ self.encoder_layers = encoder_layers
+ self.encoder_attention_heads = encoder_attention_heads
+ self.decoder_ffn_dim = decoder_ffn_dim
+ self.decoder_layers = decoder_layers
+ self.decoder_attention_heads = decoder_attention_heads
+ self.dropout = dropout
+ self.attention_dropout = attention_dropout
+ self.activation_dropout = activation_dropout
+ self.activation_function = activation_function
+ self.init_std = init_std
+ self.init_xavier_std = init_xavier_std
+ self.encoder_layerdrop = encoder_layerdrop
+ self.auxiliary_loss = auxiliary_loss
+ self.position_embedding_type = position_embedding_type
+ self.backbone = backbone
+ self.use_pretrained_backbone = use_pretrained_backbone
+ self.backbone_kwargs = backbone_kwargs
+ self.dilation = dilation
+ # deformable attributes
+ self.num_feature_levels = num_feature_levels
+ self.encoder_n_points = encoder_n_points
+ self.decoder_n_points = decoder_n_points
+ self.two_stage = two_stage
+ self.two_stage_num_proposals = two_stage_num_proposals
+ self.with_box_refine = with_box_refine
+ if two_stage is True and with_box_refine is False:
+ raise ValueError("If two_stage is True, with_box_refine must be True.")
+ # Hungarian matcher
+ self.class_cost = class_cost
+ self.bbox_cost = bbox_cost
+ self.giou_cost = giou_cost
+ # Loss coefficients
+ self.mask_loss_coefficient = mask_loss_coefficient
+ self.dice_loss_coefficient = dice_loss_coefficient
+ self.bbox_loss_coefficient = bbox_loss_coefficient
+ self.giou_loss_coefficient = giou_loss_coefficient
+ self.eos_coefficient = eos_coefficient
+ self.focal_alpha = focal_alpha
+ self.disable_custom_kernels = disable_custom_kernels
+ super().__init__(is_encoder_decoder=is_encoder_decoder, **kwargs)
+
+ @property
+ def num_attention_heads(self) -> int:
+ return self.encoder_attention_heads
+
+ @property
+ def hidden_size(self) -> int:
+ return self.d_model
+
+
+__all__ = ["DeformableDetrConfig"]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/feature_extraction_deformable_detr.py b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/feature_extraction_deformable_detr.py
new file mode 100644
index 0000000000000000000000000000000000000000..de1676740647f65dddee160ea88b2026bb6551a9
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/feature_extraction_deformable_detr.py
@@ -0,0 +1,46 @@
+# coding=utf-8
+# Copyright 2022 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Feature extractor class for Deformable DETR."""
+
+import warnings
+
+from ...image_transforms import rgb_to_id as _rgb_to_id
+from ...utils import logging
+from .image_processing_deformable_detr import DeformableDetrImageProcessor
+
+
+logger = logging.get_logger(__name__)
+
+
+def rgb_to_id(x):
+ warnings.warn(
+ "rgb_to_id has moved and will not be importable from this module from v5. "
+ "Please import from transformers.image_transforms instead.",
+ FutureWarning,
+ )
+ return _rgb_to_id(x)
+
+
+class DeformableDetrFeatureExtractor(DeformableDetrImageProcessor):
+ def __init__(self, *args, **kwargs) -> None:
+ warnings.warn(
+ "The class DeformableDetrFeatureExtractor is deprecated and will be removed in version 5 of Transformers."
+ " Please use DeformableDetrImageProcessor instead.",
+ FutureWarning,
+ )
+ super().__init__(*args, **kwargs)
+
+
+__all__ = ["DeformableDetrFeatureExtractor"]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/image_processing_deformable_detr.py b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/image_processing_deformable_detr.py
new file mode 100644
index 0000000000000000000000000000000000000000..e44733be812e5d7409c8fba5039912ebd977bcff
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/image_processing_deformable_detr.py
@@ -0,0 +1,1631 @@
+# coding=utf-8
+# Copyright 2022 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Image processor class for Deformable DETR."""
+
+import io
+import pathlib
+from collections import defaultdict
+from typing import Any, Callable, Dict, Iterable, List, Optional, Set, Tuple, Union
+
+import numpy as np
+
+from ...feature_extraction_utils import BatchFeature
+from ...image_processing_utils import BaseImageProcessor, get_size_dict
+from ...image_transforms import (
+ PaddingMode,
+ center_to_corners_format,
+ corners_to_center_format,
+ id_to_rgb,
+ pad,
+ rescale,
+ resize,
+ rgb_to_id,
+ to_channel_dimension_format,
+)
+from ...image_utils import (
+ IMAGENET_DEFAULT_MEAN,
+ IMAGENET_DEFAULT_STD,
+ AnnotationFormat,
+ AnnotationType,
+ ChannelDimension,
+ ImageInput,
+ PILImageResampling,
+ get_image_size,
+ infer_channel_dimension_format,
+ is_scaled_image,
+ make_list_of_images,
+ to_numpy_array,
+ valid_images,
+ validate_annotations,
+ validate_kwargs,
+ validate_preprocess_arguments,
+)
+from ...utils import (
+ TensorType,
+ is_flax_available,
+ is_jax_tensor,
+ is_scipy_available,
+ is_tf_available,
+ is_tf_tensor,
+ is_torch_available,
+ is_torch_tensor,
+ is_vision_available,
+ logging,
+)
+
+
+if is_torch_available():
+ import torch
+ from torch import nn
+
+
+if is_vision_available():
+ import PIL
+
+if is_scipy_available():
+ import scipy.special
+ import scipy.stats
+
+
+logger = logging.get_logger(__name__) # pylint: disable=invalid-name
+
+SUPPORTED_ANNOTATION_FORMATS = (AnnotationFormat.COCO_DETECTION, AnnotationFormat.COCO_PANOPTIC)
+
+
+# Copied from transformers.models.detr.image_processing_detr.get_size_with_aspect_ratio
+def get_size_with_aspect_ratio(image_size, size, max_size=None) -> Tuple[int, int]:
+ """
+ Computes the output image size given the input image size and the desired output size.
+
+ Args:
+ image_size (`Tuple[int, int]`):
+ The input image size.
+ size (`int`):
+ The desired output size.
+ max_size (`int`, *optional*):
+ The maximum allowed output size.
+ """
+ height, width = image_size
+ raw_size = None
+ if max_size is not None:
+ min_original_size = float(min((height, width)))
+ max_original_size = float(max((height, width)))
+ if max_original_size / min_original_size * size > max_size:
+ raw_size = max_size * min_original_size / max_original_size
+ size = int(round(raw_size))
+
+ if (height <= width and height == size) or (width <= height and width == size):
+ oh, ow = height, width
+ elif width < height:
+ ow = size
+ if max_size is not None and raw_size is not None:
+ oh = int(raw_size * height / width)
+ else:
+ oh = int(size * height / width)
+ else:
+ oh = size
+ if max_size is not None and raw_size is not None:
+ ow = int(raw_size * width / height)
+ else:
+ ow = int(size * width / height)
+
+ return (oh, ow)
+
+
+# Copied from transformers.models.detr.image_processing_detr.get_resize_output_image_size
+def get_resize_output_image_size(
+ input_image: np.ndarray,
+ size: Union[int, Tuple[int, int], List[int]],
+ max_size: Optional[int] = None,
+ input_data_format: Optional[Union[str, ChannelDimension]] = None,
+) -> Tuple[int, int]:
+ """
+ Computes the output image size given the input image size and the desired output size. If the desired output size
+ is a tuple or list, the output image size is returned as is. If the desired output size is an integer, the output
+ image size is computed by keeping the aspect ratio of the input image size.
+
+ Args:
+ input_image (`np.ndarray`):
+ The image to resize.
+ size (`int` or `Tuple[int, int]` or `List[int]`):
+ The desired output size.
+ max_size (`int`, *optional*):
+ The maximum allowed output size.
+ input_data_format (`ChannelDimension` or `str`, *optional*):
+ The channel dimension format of the input image. If not provided, it will be inferred from the input image.
+ """
+ image_size = get_image_size(input_image, input_data_format)
+ if isinstance(size, (list, tuple)):
+ return size
+
+ return get_size_with_aspect_ratio(image_size, size, max_size)
+
+
+# Copied from transformers.models.detr.image_processing_detr.get_image_size_for_max_height_width
+def get_image_size_for_max_height_width(
+ input_image: np.ndarray,
+ max_height: int,
+ max_width: int,
+ input_data_format: Optional[Union[str, ChannelDimension]] = None,
+) -> Tuple[int, int]:
+ """
+ Computes the output image size given the input image and the maximum allowed height and width. Keep aspect ratio.
+ Important, even if image_height < max_height and image_width < max_width, the image will be resized
+ to at least one of the edges be equal to max_height or max_width.
+
+ For example:
+ - input_size: (100, 200), max_height: 50, max_width: 50 -> output_size: (25, 50)
+ - input_size: (100, 200), max_height: 200, max_width: 500 -> output_size: (200, 400)
+
+ Args:
+ input_image (`np.ndarray`):
+ The image to resize.
+ max_height (`int`):
+ The maximum allowed height.
+ max_width (`int`):
+ The maximum allowed width.
+ input_data_format (`ChannelDimension` or `str`, *optional*):
+ The channel dimension format of the input image. If not provided, it will be inferred from the input image.
+ """
+ image_size = get_image_size(input_image, input_data_format)
+ height, width = image_size
+ height_scale = max_height / height
+ width_scale = max_width / width
+ min_scale = min(height_scale, width_scale)
+ new_height = int(height * min_scale)
+ new_width = int(width * min_scale)
+ return new_height, new_width
+
+
+# Copied from transformers.models.detr.image_processing_detr.get_numpy_to_framework_fn
+def get_numpy_to_framework_fn(arr) -> Callable:
+ """
+ Returns a function that converts a numpy array to the framework of the input array.
+
+ Args:
+ arr (`np.ndarray`): The array to convert.
+ """
+ if isinstance(arr, np.ndarray):
+ return np.array
+ if is_tf_available() and is_tf_tensor(arr):
+ import tensorflow as tf
+
+ return tf.convert_to_tensor
+ if is_torch_available() and is_torch_tensor(arr):
+ import torch
+
+ return torch.tensor
+ if is_flax_available() and is_jax_tensor(arr):
+ import jax.numpy as jnp
+
+ return jnp.array
+ raise ValueError(f"Cannot convert arrays of type {type(arr)}")
+
+
+# Copied from transformers.models.detr.image_processing_detr.safe_squeeze
+def safe_squeeze(arr: np.ndarray, axis: Optional[int] = None) -> np.ndarray:
+ """
+ Squeezes an array, but only if the axis specified has dim 1.
+ """
+ if axis is None:
+ return arr.squeeze()
+
+ try:
+ return arr.squeeze(axis=axis)
+ except ValueError:
+ return arr
+
+
+# Copied from transformers.models.detr.image_processing_detr.normalize_annotation
+def normalize_annotation(annotation: Dict, image_size: Tuple[int, int]) -> Dict:
+ image_height, image_width = image_size
+ norm_annotation = {}
+ for key, value in annotation.items():
+ if key == "boxes":
+ boxes = value
+ boxes = corners_to_center_format(boxes)
+ boxes /= np.asarray([image_width, image_height, image_width, image_height], dtype=np.float32)
+ norm_annotation[key] = boxes
+ else:
+ norm_annotation[key] = value
+ return norm_annotation
+
+
+# Copied from transformers.models.detr.image_processing_detr.max_across_indices
+def max_across_indices(values: Iterable[Any]) -> List[Any]:
+ """
+ Return the maximum value across all indices of an iterable of values.
+ """
+ return [max(values_i) for values_i in zip(*values)]
+
+
+# Copied from transformers.models.detr.image_processing_detr.get_max_height_width
+def get_max_height_width(
+ images: List[np.ndarray], input_data_format: Optional[Union[str, ChannelDimension]] = None
+) -> List[int]:
+ """
+ Get the maximum height and width across all images in a batch.
+ """
+ if input_data_format is None:
+ input_data_format = infer_channel_dimension_format(images[0])
+
+ if input_data_format == ChannelDimension.FIRST:
+ _, max_height, max_width = max_across_indices([img.shape for img in images])
+ elif input_data_format == ChannelDimension.LAST:
+ max_height, max_width, _ = max_across_indices([img.shape for img in images])
+ else:
+ raise ValueError(f"Invalid channel dimension format: {input_data_format}")
+ return (max_height, max_width)
+
+
+# Copied from transformers.models.detr.image_processing_detr.make_pixel_mask
+def make_pixel_mask(
+ image: np.ndarray, output_size: Tuple[int, int], input_data_format: Optional[Union[str, ChannelDimension]] = None
+) -> np.ndarray:
+ """
+ Make a pixel mask for the image, where 1 indicates a valid pixel and 0 indicates padding.
+
+ Args:
+ image (`np.ndarray`):
+ Image to make the pixel mask for.
+ output_size (`Tuple[int, int]`):
+ Output size of the mask.
+ """
+ input_height, input_width = get_image_size(image, channel_dim=input_data_format)
+ mask = np.zeros(output_size, dtype=np.int64)
+ mask[:input_height, :input_width] = 1
+ return mask
+
+
+# Copied from transformers.models.detr.image_processing_detr.convert_coco_poly_to_mask
+def convert_coco_poly_to_mask(segmentations, height: int, width: int) -> np.ndarray:
+ """
+ Convert a COCO polygon annotation to a mask.
+
+ Args:
+ segmentations (`List[List[float]]`):
+ List of polygons, each polygon represented by a list of x-y coordinates.
+ height (`int`):
+ Height of the mask.
+ width (`int`):
+ Width of the mask.
+ """
+ try:
+ from pycocotools import mask as coco_mask
+ except ImportError:
+ raise ImportError("Pycocotools is not installed in your environment.")
+
+ masks = []
+ for polygons in segmentations:
+ rles = coco_mask.frPyObjects(polygons, height, width)
+ mask = coco_mask.decode(rles)
+ if len(mask.shape) < 3:
+ mask = mask[..., None]
+ mask = np.asarray(mask, dtype=np.uint8)
+ mask = np.any(mask, axis=2)
+ masks.append(mask)
+ if masks:
+ masks = np.stack(masks, axis=0)
+ else:
+ masks = np.zeros((0, height, width), dtype=np.uint8)
+
+ return masks
+
+
+# Copied from transformers.models.detr.image_processing_detr.prepare_coco_detection_annotation with DETR->DeformableDetr
+def prepare_coco_detection_annotation(
+ image,
+ target,
+ return_segmentation_masks: bool = False,
+ input_data_format: Optional[Union[ChannelDimension, str]] = None,
+):
+ """
+ Convert the target in COCO format into the format expected by DeformableDetr.
+ """
+ image_height, image_width = get_image_size(image, channel_dim=input_data_format)
+
+ image_id = target["image_id"]
+ image_id = np.asarray([image_id], dtype=np.int64)
+
+ # Get all COCO annotations for the given image.
+ annotations = target["annotations"]
+ annotations = [obj for obj in annotations if "iscrowd" not in obj or obj["iscrowd"] == 0]
+
+ classes = [obj["category_id"] for obj in annotations]
+ classes = np.asarray(classes, dtype=np.int64)
+
+ # for conversion to coco api
+ area = np.asarray([obj["area"] for obj in annotations], dtype=np.float32)
+ iscrowd = np.asarray([obj["iscrowd"] if "iscrowd" in obj else 0 for obj in annotations], dtype=np.int64)
+
+ boxes = [obj["bbox"] for obj in annotations]
+ # guard against no boxes via resizing
+ boxes = np.asarray(boxes, dtype=np.float32).reshape(-1, 4)
+ boxes[:, 2:] += boxes[:, :2]
+ boxes[:, 0::2] = boxes[:, 0::2].clip(min=0, max=image_width)
+ boxes[:, 1::2] = boxes[:, 1::2].clip(min=0, max=image_height)
+
+ keep = (boxes[:, 3] > boxes[:, 1]) & (boxes[:, 2] > boxes[:, 0])
+
+ new_target = {}
+ new_target["image_id"] = image_id
+ new_target["class_labels"] = classes[keep]
+ new_target["boxes"] = boxes[keep]
+ new_target["area"] = area[keep]
+ new_target["iscrowd"] = iscrowd[keep]
+ new_target["orig_size"] = np.asarray([int(image_height), int(image_width)], dtype=np.int64)
+
+ if annotations and "keypoints" in annotations[0]:
+ keypoints = [obj["keypoints"] for obj in annotations]
+ # Converting the filtered keypoints list to a numpy array
+ keypoints = np.asarray(keypoints, dtype=np.float32)
+ # Apply the keep mask here to filter the relevant annotations
+ keypoints = keypoints[keep]
+ num_keypoints = keypoints.shape[0]
+ keypoints = keypoints.reshape((-1, 3)) if num_keypoints else keypoints
+ new_target["keypoints"] = keypoints
+
+ if return_segmentation_masks:
+ segmentation_masks = [obj["segmentation"] for obj in annotations]
+ masks = convert_coco_poly_to_mask(segmentation_masks, image_height, image_width)
+ new_target["masks"] = masks[keep]
+
+ return new_target
+
+
+# Copied from transformers.models.detr.image_processing_detr.masks_to_boxes
+def masks_to_boxes(masks: np.ndarray) -> np.ndarray:
+ """
+ Compute the bounding boxes around the provided panoptic segmentation masks.
+
+ Args:
+ masks: masks in format `[number_masks, height, width]` where N is the number of masks
+
+ Returns:
+ boxes: bounding boxes in format `[number_masks, 4]` in xyxy format
+ """
+ if masks.size == 0:
+ return np.zeros((0, 4))
+
+ h, w = masks.shape[-2:]
+ y = np.arange(0, h, dtype=np.float32)
+ x = np.arange(0, w, dtype=np.float32)
+ # see https://github.com/pytorch/pytorch/issues/50276
+ y, x = np.meshgrid(y, x, indexing="ij")
+
+ x_mask = masks * np.expand_dims(x, axis=0)
+ x_max = x_mask.reshape(x_mask.shape[0], -1).max(-1)
+ x = np.ma.array(x_mask, mask=~(np.array(masks, dtype=bool)))
+ x_min = x.filled(fill_value=1e8)
+ x_min = x_min.reshape(x_min.shape[0], -1).min(-1)
+
+ y_mask = masks * np.expand_dims(y, axis=0)
+ y_max = y_mask.reshape(x_mask.shape[0], -1).max(-1)
+ y = np.ma.array(y_mask, mask=~(np.array(masks, dtype=bool)))
+ y_min = y.filled(fill_value=1e8)
+ y_min = y_min.reshape(y_min.shape[0], -1).min(-1)
+
+ return np.stack([x_min, y_min, x_max, y_max], 1)
+
+
+# Copied from transformers.models.detr.image_processing_detr.prepare_coco_panoptic_annotation with DETR->DeformableDetr
+def prepare_coco_panoptic_annotation(
+ image: np.ndarray,
+ target: Dict,
+ masks_path: Union[str, pathlib.Path],
+ return_masks: bool = True,
+ input_data_format: Union[ChannelDimension, str] = None,
+) -> Dict:
+ """
+ Prepare a coco panoptic annotation for DeformableDetr.
+ """
+ image_height, image_width = get_image_size(image, channel_dim=input_data_format)
+ annotation_path = pathlib.Path(masks_path) / target["file_name"]
+
+ new_target = {}
+ new_target["image_id"] = np.asarray([target["image_id"] if "image_id" in target else target["id"]], dtype=np.int64)
+ new_target["size"] = np.asarray([image_height, image_width], dtype=np.int64)
+ new_target["orig_size"] = np.asarray([image_height, image_width], dtype=np.int64)
+
+ if "segments_info" in target:
+ masks = np.asarray(PIL.Image.open(annotation_path), dtype=np.uint32)
+ masks = rgb_to_id(masks)
+
+ ids = np.array([segment_info["id"] for segment_info in target["segments_info"]])
+ masks = masks == ids[:, None, None]
+ masks = masks.astype(np.uint8)
+ if return_masks:
+ new_target["masks"] = masks
+ new_target["boxes"] = masks_to_boxes(masks)
+ new_target["class_labels"] = np.array(
+ [segment_info["category_id"] for segment_info in target["segments_info"]], dtype=np.int64
+ )
+ new_target["iscrowd"] = np.asarray(
+ [segment_info["iscrowd"] for segment_info in target["segments_info"]], dtype=np.int64
+ )
+ new_target["area"] = np.asarray(
+ [segment_info["area"] for segment_info in target["segments_info"]], dtype=np.float32
+ )
+
+ return new_target
+
+
+# Copied from transformers.models.detr.image_processing_detr.get_segmentation_image
+def get_segmentation_image(
+ masks: np.ndarray, input_size: Tuple, target_size: Tuple, stuff_equiv_classes, deduplicate=False
+):
+ h, w = input_size
+ final_h, final_w = target_size
+
+ m_id = scipy.special.softmax(masks.transpose(0, 1), -1)
+
+ if m_id.shape[-1] == 0:
+ # We didn't detect any mask :(
+ m_id = np.zeros((h, w), dtype=np.int64)
+ else:
+ m_id = m_id.argmax(-1).reshape(h, w)
+
+ if deduplicate:
+ # Merge the masks corresponding to the same stuff class
+ for equiv in stuff_equiv_classes.values():
+ for eq_id in equiv:
+ m_id[m_id == eq_id] = equiv[0]
+
+ seg_img = id_to_rgb(m_id)
+ seg_img = resize(seg_img, (final_w, final_h), resample=PILImageResampling.NEAREST)
+ return seg_img
+
+
+# Copied from transformers.models.detr.image_processing_detr.get_mask_area
+def get_mask_area(seg_img: np.ndarray, target_size: Tuple[int, int], n_classes: int) -> np.ndarray:
+ final_h, final_w = target_size
+ np_seg_img = seg_img.astype(np.uint8)
+ np_seg_img = np_seg_img.reshape(final_h, final_w, 3)
+ m_id = rgb_to_id(np_seg_img)
+ area = [(m_id == i).sum() for i in range(n_classes)]
+ return area
+
+
+# Copied from transformers.models.detr.image_processing_detr.score_labels_from_class_probabilities
+def score_labels_from_class_probabilities(logits: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+ probs = scipy.special.softmax(logits, axis=-1)
+ labels = probs.argmax(-1, keepdims=True)
+ scores = np.take_along_axis(probs, labels, axis=-1)
+ scores, labels = scores.squeeze(-1), labels.squeeze(-1)
+ return scores, labels
+
+
+# Copied from transformers.models.detr.image_processing_detr.post_process_panoptic_sample
+def post_process_panoptic_sample(
+ out_logits: np.ndarray,
+ masks: np.ndarray,
+ boxes: np.ndarray,
+ processed_size: Tuple[int, int],
+ target_size: Tuple[int, int],
+ is_thing_map: Dict,
+ threshold=0.85,
+) -> Dict:
+ """
+ Converts the output of [`DetrForSegmentation`] into panoptic segmentation predictions for a single sample.
+
+ Args:
+ out_logits (`torch.Tensor`):
+ The logits for this sample.
+ masks (`torch.Tensor`):
+ The predicted segmentation masks for this sample.
+ boxes (`torch.Tensor`):
+ The prediced bounding boxes for this sample. The boxes are in the normalized format `(center_x, center_y,
+ width, height)` and values between `[0, 1]`, relative to the size the image (disregarding padding).
+ processed_size (`Tuple[int, int]`):
+ The processed size of the image `(height, width)`, as returned by the preprocessing step i.e. the size
+ after data augmentation but before batching.
+ target_size (`Tuple[int, int]`):
+ The target size of the image, `(height, width)` corresponding to the requested final size of the
+ prediction.
+ is_thing_map (`Dict`):
+ A dictionary mapping class indices to a boolean value indicating whether the class is a thing or not.
+ threshold (`float`, *optional*, defaults to 0.85):
+ The threshold used to binarize the segmentation masks.
+ """
+ # we filter empty queries and detection below threshold
+ scores, labels = score_labels_from_class_probabilities(out_logits)
+ keep = (labels != out_logits.shape[-1] - 1) & (scores > threshold)
+
+ cur_scores = scores[keep]
+ cur_classes = labels[keep]
+ cur_boxes = center_to_corners_format(boxes[keep])
+
+ if len(cur_boxes) != len(cur_classes):
+ raise ValueError("Not as many boxes as there are classes")
+
+ cur_masks = masks[keep]
+ cur_masks = resize(cur_masks[:, None], processed_size, resample=PILImageResampling.BILINEAR)
+ cur_masks = safe_squeeze(cur_masks, 1)
+ b, h, w = cur_masks.shape
+
+ # It may be that we have several predicted masks for the same stuff class.
+ # In the following, we track the list of masks ids for each stuff class (they are merged later on)
+ cur_masks = cur_masks.reshape(b, -1)
+ stuff_equiv_classes = defaultdict(list)
+ for k, label in enumerate(cur_classes):
+ if not is_thing_map[label]:
+ stuff_equiv_classes[label].append(k)
+
+ seg_img = get_segmentation_image(cur_masks, processed_size, target_size, stuff_equiv_classes, deduplicate=True)
+ area = get_mask_area(cur_masks, processed_size, n_classes=len(cur_scores))
+
+ # We filter out any mask that is too small
+ if cur_classes.size() > 0:
+ # We know filter empty masks as long as we find some
+ filtered_small = np.array([a <= 4 for a in area], dtype=bool)
+ while filtered_small.any():
+ cur_masks = cur_masks[~filtered_small]
+ cur_scores = cur_scores[~filtered_small]
+ cur_classes = cur_classes[~filtered_small]
+ seg_img = get_segmentation_image(cur_masks, (h, w), target_size, stuff_equiv_classes, deduplicate=True)
+ area = get_mask_area(seg_img, target_size, n_classes=len(cur_scores))
+ filtered_small = np.array([a <= 4 for a in area], dtype=bool)
+ else:
+ cur_classes = np.ones((1, 1), dtype=np.int64)
+
+ segments_info = [
+ {"id": i, "isthing": is_thing_map[cat], "category_id": int(cat), "area": a}
+ for i, (cat, a) in enumerate(zip(cur_classes, area))
+ ]
+ del cur_classes
+
+ with io.BytesIO() as out:
+ PIL.Image.fromarray(seg_img).save(out, format="PNG")
+ predictions = {"png_string": out.getvalue(), "segments_info": segments_info}
+
+ return predictions
+
+
+# Copied from transformers.models.detr.image_processing_detr.resize_annotation
+def resize_annotation(
+ annotation: Dict[str, Any],
+ orig_size: Tuple[int, int],
+ target_size: Tuple[int, int],
+ threshold: float = 0.5,
+ resample: PILImageResampling = PILImageResampling.NEAREST,
+):
+ """
+ Resizes an annotation to a target size.
+
+ Args:
+ annotation (`Dict[str, Any]`):
+ The annotation dictionary.
+ orig_size (`Tuple[int, int]`):
+ The original size of the input image.
+ target_size (`Tuple[int, int]`):
+ The target size of the image, as returned by the preprocessing `resize` step.
+ threshold (`float`, *optional*, defaults to 0.5):
+ The threshold used to binarize the segmentation masks.
+ resample (`PILImageResampling`, defaults to `PILImageResampling.NEAREST`):
+ The resampling filter to use when resizing the masks.
+ """
+ ratios = tuple(float(s) / float(s_orig) for s, s_orig in zip(target_size, orig_size))
+ ratio_height, ratio_width = ratios
+
+ new_annotation = {}
+ new_annotation["size"] = target_size
+
+ for key, value in annotation.items():
+ if key == "boxes":
+ boxes = value
+ scaled_boxes = boxes * np.asarray([ratio_width, ratio_height, ratio_width, ratio_height], dtype=np.float32)
+ new_annotation["boxes"] = scaled_boxes
+ elif key == "area":
+ area = value
+ scaled_area = area * (ratio_width * ratio_height)
+ new_annotation["area"] = scaled_area
+ elif key == "masks":
+ masks = value[:, None]
+ masks = np.array([resize(mask, target_size, resample=resample) for mask in masks])
+ masks = masks.astype(np.float32)
+ masks = masks[:, 0] > threshold
+ new_annotation["masks"] = masks
+ elif key == "size":
+ new_annotation["size"] = target_size
+ else:
+ new_annotation[key] = value
+
+ return new_annotation
+
+
+# Copied from transformers.models.detr.image_processing_detr.binary_mask_to_rle
+def binary_mask_to_rle(mask):
+ """
+ Converts given binary mask of shape `(height, width)` to the run-length encoding (RLE) format.
+
+ Args:
+ mask (`torch.Tensor` or `numpy.array`):
+ A binary mask tensor of shape `(height, width)` where 0 denotes background and 1 denotes the target
+ segment_id or class_id.
+ Returns:
+ `List`: Run-length encoded list of the binary mask. Refer to COCO API for more information about the RLE
+ format.
+ """
+ if is_torch_tensor(mask):
+ mask = mask.numpy()
+
+ pixels = mask.flatten()
+ pixels = np.concatenate([[0], pixels, [0]])
+ runs = np.where(pixels[1:] != pixels[:-1])[0] + 1
+ runs[1::2] -= runs[::2]
+ return list(runs)
+
+
+# Copied from transformers.models.detr.image_processing_detr.convert_segmentation_to_rle
+def convert_segmentation_to_rle(segmentation):
+ """
+ Converts given segmentation map of shape `(height, width)` to the run-length encoding (RLE) format.
+
+ Args:
+ segmentation (`torch.Tensor` or `numpy.array`):
+ A segmentation map of shape `(height, width)` where each value denotes a segment or class id.
+ Returns:
+ `List[List]`: A list of lists, where each list is the run-length encoding of a segment / class id.
+ """
+ segment_ids = torch.unique(segmentation)
+
+ run_length_encodings = []
+ for idx in segment_ids:
+ mask = torch.where(segmentation == idx, 1, 0)
+ rle = binary_mask_to_rle(mask)
+ run_length_encodings.append(rle)
+
+ return run_length_encodings
+
+
+# Copied from transformers.models.detr.image_processing_detr.remove_low_and_no_objects
+def remove_low_and_no_objects(masks, scores, labels, object_mask_threshold, num_labels):
+ """
+ Binarize the given masks using `object_mask_threshold`, it returns the associated values of `masks`, `scores` and
+ `labels`.
+
+ Args:
+ masks (`torch.Tensor`):
+ A tensor of shape `(num_queries, height, width)`.
+ scores (`torch.Tensor`):
+ A tensor of shape `(num_queries)`.
+ labels (`torch.Tensor`):
+ A tensor of shape `(num_queries)`.
+ object_mask_threshold (`float`):
+ A number between 0 and 1 used to binarize the masks.
+ Raises:
+ `ValueError`: Raised when the first dimension doesn't match in all input tensors.
+ Returns:
+ `Tuple[`torch.Tensor`, `torch.Tensor`, `torch.Tensor`]`: The `masks`, `scores` and `labels` without the region
+ < `object_mask_threshold`.
+ """
+ if not (masks.shape[0] == scores.shape[0] == labels.shape[0]):
+ raise ValueError("mask, scores and labels must have the same shape!")
+
+ to_keep = labels.ne(num_labels) & (scores > object_mask_threshold)
+
+ return masks[to_keep], scores[to_keep], labels[to_keep]
+
+
+# Copied from transformers.models.detr.image_processing_detr.check_segment_validity
+def check_segment_validity(mask_labels, mask_probs, k, mask_threshold=0.5, overlap_mask_area_threshold=0.8):
+ # Get the mask associated with the k class
+ mask_k = mask_labels == k
+ mask_k_area = mask_k.sum()
+
+ # Compute the area of all the stuff in query k
+ original_area = (mask_probs[k] >= mask_threshold).sum()
+ mask_exists = mask_k_area > 0 and original_area > 0
+
+ # Eliminate disconnected tiny segments
+ if mask_exists:
+ area_ratio = mask_k_area / original_area
+ if not area_ratio.item() > overlap_mask_area_threshold:
+ mask_exists = False
+
+ return mask_exists, mask_k
+
+
+# Copied from transformers.models.detr.image_processing_detr.compute_segments
+def compute_segments(
+ mask_probs,
+ pred_scores,
+ pred_labels,
+ mask_threshold: float = 0.5,
+ overlap_mask_area_threshold: float = 0.8,
+ label_ids_to_fuse: Optional[Set[int]] = None,
+ target_size: Tuple[int, int] = None,
+):
+ height = mask_probs.shape[1] if target_size is None else target_size[0]
+ width = mask_probs.shape[2] if target_size is None else target_size[1]
+
+ segmentation = torch.zeros((height, width), dtype=torch.int32, device=mask_probs.device)
+ segments: List[Dict] = []
+
+ if target_size is not None:
+ mask_probs = nn.functional.interpolate(
+ mask_probs.unsqueeze(0), size=target_size, mode="bilinear", align_corners=False
+ )[0]
+
+ current_segment_id = 0
+
+ # Weigh each mask by its prediction score
+ mask_probs *= pred_scores.view(-1, 1, 1)
+ mask_labels = mask_probs.argmax(0) # [height, width]
+
+ # Keep track of instances of each class
+ stuff_memory_list: Dict[str, int] = {}
+ for k in range(pred_labels.shape[0]):
+ pred_class = pred_labels[k].item()
+ should_fuse = pred_class in label_ids_to_fuse
+
+ # Check if mask exists and large enough to be a segment
+ mask_exists, mask_k = check_segment_validity(
+ mask_labels, mask_probs, k, mask_threshold, overlap_mask_area_threshold
+ )
+
+ if mask_exists:
+ if pred_class in stuff_memory_list:
+ current_segment_id = stuff_memory_list[pred_class]
+ else:
+ current_segment_id += 1
+
+ # Add current object segment to final segmentation map
+ segmentation[mask_k] = current_segment_id
+ segment_score = round(pred_scores[k].item(), 6)
+ segments.append(
+ {
+ "id": current_segment_id,
+ "label_id": pred_class,
+ "was_fused": should_fuse,
+ "score": segment_score,
+ }
+ )
+ if should_fuse:
+ stuff_memory_list[pred_class] = current_segment_id
+
+ return segmentation, segments
+
+
+class DeformableDetrImageProcessor(BaseImageProcessor):
+ r"""
+ Constructs a Deformable DETR image processor.
+
+ Args:
+ format (`str`, *optional*, defaults to `"coco_detection"`):
+ Data format of the annotations. One of "coco_detection" or "coco_panoptic".
+ do_resize (`bool`, *optional*, defaults to `True`):
+ Controls whether to resize the image's (height, width) dimensions to the specified `size`. Can be
+ overridden by the `do_resize` parameter in the `preprocess` method.
+ size (`Dict[str, int]` *optional*, defaults to `{"shortest_edge": 800, "longest_edge": 1333}`):
+ Size of the image's `(height, width)` dimensions after resizing. Can be overridden by the `size` parameter
+ in the `preprocess` method. Available options are:
+ - `{"height": int, "width": int}`: The image will be resized to the exact size `(height, width)`.
+ Do NOT keep the aspect ratio.
+ - `{"shortest_edge": int, "longest_edge": int}`: The image will be resized to a maximum size respecting
+ the aspect ratio and keeping the shortest edge less or equal to `shortest_edge` and the longest edge
+ less or equal to `longest_edge`.
+ - `{"max_height": int, "max_width": int}`: The image will be resized to the maximum size respecting the
+ aspect ratio and keeping the height less or equal to `max_height` and the width less or equal to
+ `max_width`.
+ resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BILINEAR`):
+ Resampling filter to use if resizing the image.
+ do_rescale (`bool`, *optional*, defaults to `True`):
+ Controls whether to rescale the image by the specified scale `rescale_factor`. Can be overridden by the
+ `do_rescale` parameter in the `preprocess` method.
+ rescale_factor (`int` or `float`, *optional*, defaults to `1/255`):
+ Scale factor to use if rescaling the image. Can be overridden by the `rescale_factor` parameter in the
+ `preprocess` method.
+ do_normalize:
+ Controls whether to normalize the image. Can be overridden by the `do_normalize` parameter in the
+ `preprocess` method.
+ image_mean (`float` or `List[float]`, *optional*, defaults to `IMAGENET_DEFAULT_MEAN`):
+ Mean values to use when normalizing the image. Can be a single value or a list of values, one for each
+ channel. Can be overridden by the `image_mean` parameter in the `preprocess` method.
+ image_std (`float` or `List[float]`, *optional*, defaults to `IMAGENET_DEFAULT_STD`):
+ Standard deviation values to use when normalizing the image. Can be a single value or a list of values, one
+ for each channel. Can be overridden by the `image_std` parameter in the `preprocess` method.
+ do_convert_annotations (`bool`, *optional*, defaults to `True`):
+ Controls whether to convert the annotations to the format expected by the DETR model. Converts the
+ bounding boxes to the format `(center_x, center_y, width, height)` and in the range `[0, 1]`.
+ Can be overridden by the `do_convert_annotations` parameter in the `preprocess` method.
+ do_pad (`bool`, *optional*, defaults to `True`):
+ Controls whether to pad the image. Can be overridden by the `do_pad` parameter in the `preprocess`
+ method. If `True`, padding will be applied to the bottom and right of the image with zeros.
+ If `pad_size` is provided, the image will be padded to the specified dimensions.
+ Otherwise, the image will be padded to the maximum height and width of the batch.
+ pad_size (`Dict[str, int]`, *optional*):
+ The size `{"height": int, "width" int}` to pad the images to. Must be larger than any image size
+ provided for preprocessing. If `pad_size` is not provided, images will be padded to the largest
+ height and width in the batch.
+ """
+
+ model_input_names = ["pixel_values", "pixel_mask"]
+
+ # Copied from transformers.models.detr.image_processing_detr.DetrImageProcessor.__init__
+ def __init__(
+ self,
+ format: Union[str, AnnotationFormat] = AnnotationFormat.COCO_DETECTION,
+ do_resize: bool = True,
+ size: Dict[str, int] = None,
+ resample: PILImageResampling = PILImageResampling.BILINEAR,
+ do_rescale: bool = True,
+ rescale_factor: Union[int, float] = 1 / 255,
+ do_normalize: bool = True,
+ image_mean: Union[float, List[float]] = None,
+ image_std: Union[float, List[float]] = None,
+ do_convert_annotations: Optional[bool] = None,
+ do_pad: bool = True,
+ pad_size: Optional[Dict[str, int]] = None,
+ **kwargs,
+ ) -> None:
+ if "pad_and_return_pixel_mask" in kwargs:
+ do_pad = kwargs.pop("pad_and_return_pixel_mask")
+
+ if "max_size" in kwargs:
+ logger.warning_once(
+ "The `max_size` parameter is deprecated and will be removed in v4.26. "
+ "Please specify in `size['longest_edge'] instead`.",
+ )
+ max_size = kwargs.pop("max_size")
+ else:
+ max_size = None if size is None else 1333
+
+ size = size if size is not None else {"shortest_edge": 800, "longest_edge": 1333}
+ size = get_size_dict(size, max_size=max_size, default_to_square=False)
+
+ # Backwards compatibility
+ if do_convert_annotations is None:
+ do_convert_annotations = do_normalize
+
+ super().__init__(**kwargs)
+ self.format = format
+ self.do_resize = do_resize
+ self.size = size
+ self.resample = resample
+ self.do_rescale = do_rescale
+ self.rescale_factor = rescale_factor
+ self.do_normalize = do_normalize
+ self.do_convert_annotations = do_convert_annotations
+ self.image_mean = image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
+ self.image_std = image_std if image_std is not None else IMAGENET_DEFAULT_STD
+ self.do_pad = do_pad
+ self.pad_size = pad_size
+ self._valid_processor_keys = [
+ "images",
+ "annotations",
+ "return_segmentation_masks",
+ "masks_path",
+ "do_resize",
+ "size",
+ "resample",
+ "do_rescale",
+ "rescale_factor",
+ "do_normalize",
+ "do_convert_annotations",
+ "image_mean",
+ "image_std",
+ "do_pad",
+ "pad_size",
+ "format",
+ "return_tensors",
+ "data_format",
+ "input_data_format",
+ ]
+
+ @classmethod
+ # Copied from transformers.models.detr.image_processing_detr.DetrImageProcessor.from_dict with Detr->DeformableDetr
+ def from_dict(cls, image_processor_dict: Dict[str, Any], **kwargs):
+ """
+ Overrides the `from_dict` method from the base class to make sure parameters are updated if image processor is
+ created using from_dict and kwargs e.g. `DeformableDetrImageProcessor.from_pretrained(checkpoint, size=600,
+ max_size=800)`
+ """
+ image_processor_dict = image_processor_dict.copy()
+ if "max_size" in kwargs:
+ image_processor_dict["max_size"] = kwargs.pop("max_size")
+ if "pad_and_return_pixel_mask" in kwargs:
+ image_processor_dict["pad_and_return_pixel_mask"] = kwargs.pop("pad_and_return_pixel_mask")
+ return super().from_dict(image_processor_dict, **kwargs)
+
+ # Copied from transformers.models.detr.image_processing_detr.DetrImageProcessor.prepare_annotation with DETR->DeformableDetr
+ def prepare_annotation(
+ self,
+ image: np.ndarray,
+ target: Dict,
+ format: Optional[AnnotationFormat] = None,
+ return_segmentation_masks: bool = None,
+ masks_path: Optional[Union[str, pathlib.Path]] = None,
+ input_data_format: Optional[Union[str, ChannelDimension]] = None,
+ ) -> Dict:
+ """
+ Prepare an annotation for feeding into DeformableDetr model.
+ """
+ format = format if format is not None else self.format
+
+ if format == AnnotationFormat.COCO_DETECTION:
+ return_segmentation_masks = False if return_segmentation_masks is None else return_segmentation_masks
+ target = prepare_coco_detection_annotation(
+ image, target, return_segmentation_masks, input_data_format=input_data_format
+ )
+ elif format == AnnotationFormat.COCO_PANOPTIC:
+ return_segmentation_masks = True if return_segmentation_masks is None else return_segmentation_masks
+ target = prepare_coco_panoptic_annotation(
+ image,
+ target,
+ masks_path=masks_path,
+ return_masks=return_segmentation_masks,
+ input_data_format=input_data_format,
+ )
+ else:
+ raise ValueError(f"Format {format} is not supported.")
+ return target
+
+ # Copied from transformers.models.detr.image_processing_detr.DetrImageProcessor.resize
+ def resize(
+ self,
+ image: np.ndarray,
+ size: Dict[str, int],
+ resample: PILImageResampling = PILImageResampling.BILINEAR,
+ data_format: Optional[ChannelDimension] = None,
+ input_data_format: Optional[Union[str, ChannelDimension]] = None,
+ **kwargs,
+ ) -> np.ndarray:
+ """
+ Resize the image to the given size. Size can be `min_size` (scalar) or `(height, width)` tuple. If size is an
+ int, smaller edge of the image will be matched to this number.
+
+ Args:
+ image (`np.ndarray`):
+ Image to resize.
+ size (`Dict[str, int]`):
+ Size of the image's `(height, width)` dimensions after resizing. Available options are:
+ - `{"height": int, "width": int}`: The image will be resized to the exact size `(height, width)`.
+ Do NOT keep the aspect ratio.
+ - `{"shortest_edge": int, "longest_edge": int}`: The image will be resized to a maximum size respecting
+ the aspect ratio and keeping the shortest edge less or equal to `shortest_edge` and the longest edge
+ less or equal to `longest_edge`.
+ - `{"max_height": int, "max_width": int}`: The image will be resized to the maximum size respecting the
+ aspect ratio and keeping the height less or equal to `max_height` and the width less or equal to
+ `max_width`.
+ resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BILINEAR`):
+ Resampling filter to use if resizing the image.
+ data_format (`str` or `ChannelDimension`, *optional*):
+ The channel dimension format for the output image. If unset, the channel dimension format of the input
+ image is used.
+ input_data_format (`ChannelDimension` or `str`, *optional*):
+ The channel dimension format of the input image. If not provided, it will be inferred.
+ """
+ if "max_size" in kwargs:
+ logger.warning_once(
+ "The `max_size` parameter is deprecated and will be removed in v4.26. "
+ "Please specify in `size['longest_edge'] instead`.",
+ )
+ max_size = kwargs.pop("max_size")
+ else:
+ max_size = None
+ size = get_size_dict(size, max_size=max_size, default_to_square=False)
+ if "shortest_edge" in size and "longest_edge" in size:
+ new_size = get_resize_output_image_size(
+ image, size["shortest_edge"], size["longest_edge"], input_data_format=input_data_format
+ )
+ elif "max_height" in size and "max_width" in size:
+ new_size = get_image_size_for_max_height_width(
+ image, size["max_height"], size["max_width"], input_data_format=input_data_format
+ )
+ elif "height" in size and "width" in size:
+ new_size = (size["height"], size["width"])
+ else:
+ raise ValueError(
+ "Size must contain 'height' and 'width' keys or 'shortest_edge' and 'longest_edge' keys. Got"
+ f" {size.keys()}."
+ )
+ image = resize(
+ image,
+ size=new_size,
+ resample=resample,
+ data_format=data_format,
+ input_data_format=input_data_format,
+ **kwargs,
+ )
+ return image
+
+ # Copied from transformers.models.detr.image_processing_detr.DetrImageProcessor.resize_annotation
+ def resize_annotation(
+ self,
+ annotation,
+ orig_size,
+ size,
+ resample: PILImageResampling = PILImageResampling.NEAREST,
+ ) -> Dict:
+ """
+ Resize the annotation to match the resized image. If size is an int, smaller edge of the mask will be matched
+ to this number.
+ """
+ return resize_annotation(annotation, orig_size=orig_size, target_size=size, resample=resample)
+
+ # Copied from transformers.models.detr.image_processing_detr.DetrImageProcessor.rescale
+ def rescale(
+ self,
+ image: np.ndarray,
+ rescale_factor: float,
+ data_format: Optional[Union[str, ChannelDimension]] = None,
+ input_data_format: Optional[Union[str, ChannelDimension]] = None,
+ ) -> np.ndarray:
+ """
+ Rescale the image by the given factor. image = image * rescale_factor.
+
+ Args:
+ image (`np.ndarray`):
+ Image to rescale.
+ rescale_factor (`float`):
+ The value to use for rescaling.
+ data_format (`str` or `ChannelDimension`, *optional*):
+ The channel dimension format for the output image. If unset, the channel dimension format of the input
+ image is used. Can be one of:
+ - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format.
+ - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format.
+ input_data_format (`str` or `ChannelDimension`, *optional*):
+ The channel dimension format for the input image. If unset, is inferred from the input image. Can be
+ one of:
+ - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format.
+ - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format.
+ """
+ return rescale(image, rescale_factor, data_format=data_format, input_data_format=input_data_format)
+
+ # Copied from transformers.models.detr.image_processing_detr.DetrImageProcessor.normalize_annotation
+ def normalize_annotation(self, annotation: Dict, image_size: Tuple[int, int]) -> Dict:
+ """
+ Normalize the boxes in the annotation from `[top_left_x, top_left_y, bottom_right_x, bottom_right_y]` to
+ `[center_x, center_y, width, height]` format and from absolute to relative pixel values.
+ """
+ return normalize_annotation(annotation, image_size=image_size)
+
+ # Copied from transformers.models.detr.image_processing_detr.DetrImageProcessor._update_annotation_for_padded_image
+ def _update_annotation_for_padded_image(
+ self,
+ annotation: Dict,
+ input_image_size: Tuple[int, int],
+ output_image_size: Tuple[int, int],
+ padding,
+ update_bboxes,
+ ) -> Dict:
+ """
+ Update the annotation for a padded image.
+ """
+ new_annotation = {}
+ new_annotation["size"] = output_image_size
+
+ for key, value in annotation.items():
+ if key == "masks":
+ masks = value
+ masks = pad(
+ masks,
+ padding,
+ mode=PaddingMode.CONSTANT,
+ constant_values=0,
+ input_data_format=ChannelDimension.FIRST,
+ )
+ masks = safe_squeeze(masks, 1)
+ new_annotation["masks"] = masks
+ elif key == "boxes" and update_bboxes:
+ boxes = value
+ boxes *= np.asarray(
+ [
+ input_image_size[1] / output_image_size[1],
+ input_image_size[0] / output_image_size[0],
+ input_image_size[1] / output_image_size[1],
+ input_image_size[0] / output_image_size[0],
+ ]
+ )
+ new_annotation["boxes"] = boxes
+ elif key == "size":
+ new_annotation["size"] = output_image_size
+ else:
+ new_annotation[key] = value
+ return new_annotation
+
+ # Copied from transformers.models.detr.image_processing_detr.DetrImageProcessor._pad_image
+ def _pad_image(
+ self,
+ image: np.ndarray,
+ output_size: Tuple[int, int],
+ annotation: Optional[Dict[str, Any]] = None,
+ constant_values: Union[float, Iterable[float]] = 0,
+ data_format: Optional[ChannelDimension] = None,
+ input_data_format: Optional[Union[str, ChannelDimension]] = None,
+ update_bboxes: bool = True,
+ ) -> np.ndarray:
+ """
+ Pad an image with zeros to the given size.
+ """
+ input_height, input_width = get_image_size(image, channel_dim=input_data_format)
+ output_height, output_width = output_size
+
+ pad_bottom = output_height - input_height
+ pad_right = output_width - input_width
+ padding = ((0, pad_bottom), (0, pad_right))
+ padded_image = pad(
+ image,
+ padding,
+ mode=PaddingMode.CONSTANT,
+ constant_values=constant_values,
+ data_format=data_format,
+ input_data_format=input_data_format,
+ )
+ if annotation is not None:
+ annotation = self._update_annotation_for_padded_image(
+ annotation, (input_height, input_width), (output_height, output_width), padding, update_bboxes
+ )
+ return padded_image, annotation
+
+ # Copied from transformers.models.detr.image_processing_detr.DetrImageProcessor.pad
+ def pad(
+ self,
+ images: List[np.ndarray],
+ annotations: Optional[Union[AnnotationType, List[AnnotationType]]] = None,
+ constant_values: Union[float, Iterable[float]] = 0,
+ return_pixel_mask: bool = True,
+ return_tensors: Optional[Union[str, TensorType]] = None,
+ data_format: Optional[ChannelDimension] = None,
+ input_data_format: Optional[Union[str, ChannelDimension]] = None,
+ update_bboxes: bool = True,
+ pad_size: Optional[Dict[str, int]] = None,
+ ) -> BatchFeature:
+ """
+ Pads a batch of images to the bottom and right of the image with zeros to the size of largest height and width
+ in the batch and optionally returns their corresponding pixel mask.
+
+ Args:
+ images (List[`np.ndarray`]):
+ Images to pad.
+ annotations (`AnnotationType` or `List[AnnotationType]`, *optional*):
+ Annotations to transform according to the padding that is applied to the images.
+ constant_values (`float` or `Iterable[float]`, *optional*):
+ The value to use for the padding if `mode` is `"constant"`.
+ return_pixel_mask (`bool`, *optional*, defaults to `True`):
+ Whether to return a pixel mask.
+ return_tensors (`str` or `TensorType`, *optional*):
+ The type of tensors to return. Can be one of:
+ - Unset: Return a list of `np.ndarray`.
+ - `TensorType.TENSORFLOW` or `'tf'`: Return a batch of type `tf.Tensor`.
+ - `TensorType.PYTORCH` or `'pt'`: Return a batch of type `torch.Tensor`.
+ - `TensorType.NUMPY` or `'np'`: Return a batch of type `np.ndarray`.
+ - `TensorType.JAX` or `'jax'`: Return a batch of type `jax.numpy.ndarray`.
+ data_format (`str` or `ChannelDimension`, *optional*):
+ The channel dimension format of the image. If not provided, it will be the same as the input image.
+ input_data_format (`ChannelDimension` or `str`, *optional*):
+ The channel dimension format of the input image. If not provided, it will be inferred.
+ update_bboxes (`bool`, *optional*, defaults to `True`):
+ Whether to update the bounding boxes in the annotations to match the padded images. If the
+ bounding boxes have not been converted to relative coordinates and `(centre_x, centre_y, width, height)`
+ format, the bounding boxes will not be updated.
+ pad_size (`Dict[str, int]`, *optional*):
+ The size `{"height": int, "width" int}` to pad the images to. Must be larger than any image size
+ provided for preprocessing. If `pad_size` is not provided, images will be padded to the largest
+ height and width in the batch.
+ """
+ pad_size = pad_size if pad_size is not None else self.pad_size
+ if pad_size is not None:
+ padded_size = (pad_size["height"], pad_size["width"])
+ else:
+ padded_size = get_max_height_width(images, input_data_format=input_data_format)
+
+ annotation_list = annotations if annotations is not None else [None] * len(images)
+ padded_images = []
+ padded_annotations = []
+ for image, annotation in zip(images, annotation_list):
+ padded_image, padded_annotation = self._pad_image(
+ image,
+ padded_size,
+ annotation,
+ constant_values=constant_values,
+ data_format=data_format,
+ input_data_format=input_data_format,
+ update_bboxes=update_bboxes,
+ )
+ padded_images.append(padded_image)
+ padded_annotations.append(padded_annotation)
+
+ data = {"pixel_values": padded_images}
+
+ if return_pixel_mask:
+ masks = [
+ make_pixel_mask(image=image, output_size=padded_size, input_data_format=input_data_format)
+ for image in images
+ ]
+ data["pixel_mask"] = masks
+
+ encoded_inputs = BatchFeature(data=data, tensor_type=return_tensors)
+
+ if annotations is not None:
+ encoded_inputs["labels"] = [
+ BatchFeature(annotation, tensor_type=return_tensors) for annotation in padded_annotations
+ ]
+
+ return encoded_inputs
+
+ # Copied from transformers.models.detr.image_processing_detr.DetrImageProcessor.preprocess
+ def preprocess(
+ self,
+ images: ImageInput,
+ annotations: Optional[Union[AnnotationType, List[AnnotationType]]] = None,
+ return_segmentation_masks: bool = None,
+ masks_path: Optional[Union[str, pathlib.Path]] = None,
+ do_resize: Optional[bool] = None,
+ size: Optional[Dict[str, int]] = None,
+ resample=None, # PILImageResampling
+ do_rescale: Optional[bool] = None,
+ rescale_factor: Optional[Union[int, float]] = None,
+ do_normalize: Optional[bool] = None,
+ do_convert_annotations: Optional[bool] = None,
+ image_mean: Optional[Union[float, List[float]]] = None,
+ image_std: Optional[Union[float, List[float]]] = None,
+ do_pad: Optional[bool] = None,
+ format: Optional[Union[str, AnnotationFormat]] = None,
+ return_tensors: Optional[Union[TensorType, str]] = None,
+ data_format: Union[str, ChannelDimension] = ChannelDimension.FIRST,
+ input_data_format: Optional[Union[str, ChannelDimension]] = None,
+ pad_size: Optional[Dict[str, int]] = None,
+ **kwargs,
+ ) -> BatchFeature:
+ """
+ Preprocess an image or a batch of images so that it can be used by the model.
+
+ Args:
+ images (`ImageInput`):
+ Image or batch of images to preprocess. Expects a single or batch of images with pixel values ranging
+ from 0 to 255. If passing in images with pixel values between 0 and 1, set `do_rescale=False`.
+ annotations (`AnnotationType` or `List[AnnotationType]`, *optional*):
+ List of annotations associated with the image or batch of images. If annotation is for object
+ detection, the annotations should be a dictionary with the following keys:
+ - "image_id" (`int`): The image id.
+ - "annotations" (`List[Dict]`): List of annotations for an image. Each annotation should be a
+ dictionary. An image can have no annotations, in which case the list should be empty.
+ If annotation is for segmentation, the annotations should be a dictionary with the following keys:
+ - "image_id" (`int`): The image id.
+ - "segments_info" (`List[Dict]`): List of segments for an image. Each segment should be a dictionary.
+ An image can have no segments, in which case the list should be empty.
+ - "file_name" (`str`): The file name of the image.
+ return_segmentation_masks (`bool`, *optional*, defaults to self.return_segmentation_masks):
+ Whether to return segmentation masks.
+ masks_path (`str` or `pathlib.Path`, *optional*):
+ Path to the directory containing the segmentation masks.
+ do_resize (`bool`, *optional*, defaults to self.do_resize):
+ Whether to resize the image.
+ size (`Dict[str, int]`, *optional*, defaults to self.size):
+ Size of the image's `(height, width)` dimensions after resizing. Available options are:
+ - `{"height": int, "width": int}`: The image will be resized to the exact size `(height, width)`.
+ Do NOT keep the aspect ratio.
+ - `{"shortest_edge": int, "longest_edge": int}`: The image will be resized to a maximum size respecting
+ the aspect ratio and keeping the shortest edge less or equal to `shortest_edge` and the longest edge
+ less or equal to `longest_edge`.
+ - `{"max_height": int, "max_width": int}`: The image will be resized to the maximum size respecting the
+ aspect ratio and keeping the height less or equal to `max_height` and the width less or equal to
+ `max_width`.
+ resample (`PILImageResampling`, *optional*, defaults to self.resample):
+ Resampling filter to use when resizing the image.
+ do_rescale (`bool`, *optional*, defaults to self.do_rescale):
+ Whether to rescale the image.
+ rescale_factor (`float`, *optional*, defaults to self.rescale_factor):
+ Rescale factor to use when rescaling the image.
+ do_normalize (`bool`, *optional*, defaults to self.do_normalize):
+ Whether to normalize the image.
+ do_convert_annotations (`bool`, *optional*, defaults to self.do_convert_annotations):
+ Whether to convert the annotations to the format expected by the model. Converts the bounding
+ boxes from the format `(top_left_x, top_left_y, width, height)` to `(center_x, center_y, width, height)`
+ and in relative coordinates.
+ image_mean (`float` or `List[float]`, *optional*, defaults to self.image_mean):
+ Mean to use when normalizing the image.
+ image_std (`float` or `List[float]`, *optional*, defaults to self.image_std):
+ Standard deviation to use when normalizing the image.
+ do_pad (`bool`, *optional*, defaults to self.do_pad):
+ Whether to pad the image. If `True`, padding will be applied to the bottom and right of
+ the image with zeros. If `pad_size` is provided, the image will be padded to the specified
+ dimensions. Otherwise, the image will be padded to the maximum height and width of the batch.
+ format (`str` or `AnnotationFormat`, *optional*, defaults to self.format):
+ Format of the annotations.
+ return_tensors (`str` or `TensorType`, *optional*, defaults to self.return_tensors):
+ Type of tensors to return. If `None`, will return the list of images.
+ data_format (`ChannelDimension` or `str`, *optional*, defaults to `ChannelDimension.FIRST`):
+ The channel dimension format for the output image. Can be one of:
+ - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format.
+ - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format.
+ - Unset: Use the channel dimension format of the input image.
+ input_data_format (`ChannelDimension` or `str`, *optional*):
+ The channel dimension format for the input image. If unset, the channel dimension format is inferred
+ from the input image. Can be one of:
+ - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format.
+ - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format.
+ - `"none"` or `ChannelDimension.NONE`: image in (height, width) format.
+ pad_size (`Dict[str, int]`, *optional*):
+ The size `{"height": int, "width" int}` to pad the images to. Must be larger than any image size
+ provided for preprocessing. If `pad_size` is not provided, images will be padded to the largest
+ height and width in the batch.
+ """
+ if "pad_and_return_pixel_mask" in kwargs:
+ logger.warning_once(
+ "The `pad_and_return_pixel_mask` argument is deprecated and will be removed in a future version, "
+ "use `do_pad` instead."
+ )
+ do_pad = kwargs.pop("pad_and_return_pixel_mask")
+
+ if "max_size" in kwargs:
+ logger.warning_once(
+ "The `max_size` argument is deprecated and will be removed in a future version, use"
+ " `size['longest_edge']` instead."
+ )
+ size = kwargs.pop("max_size")
+
+ do_resize = self.do_resize if do_resize is None else do_resize
+ size = self.size if size is None else size
+ size = get_size_dict(size=size, default_to_square=False)
+ resample = self.resample if resample is None else resample
+ do_rescale = self.do_rescale if do_rescale is None else do_rescale
+ rescale_factor = self.rescale_factor if rescale_factor is None else rescale_factor
+ do_normalize = self.do_normalize if do_normalize is None else do_normalize
+ image_mean = self.image_mean if image_mean is None else image_mean
+ image_std = self.image_std if image_std is None else image_std
+ do_convert_annotations = (
+ self.do_convert_annotations if do_convert_annotations is None else do_convert_annotations
+ )
+ do_pad = self.do_pad if do_pad is None else do_pad
+ pad_size = self.pad_size if pad_size is None else pad_size
+ format = self.format if format is None else format
+
+ images = make_list_of_images(images)
+
+ if not valid_images(images):
+ raise ValueError(
+ "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
+ "torch.Tensor, tf.Tensor or jax.ndarray."
+ )
+ validate_kwargs(captured_kwargs=kwargs.keys(), valid_processor_keys=self._valid_processor_keys)
+
+ # Here, the pad() method pads to the maximum of (width, height). It does not need to be validated.
+ validate_preprocess_arguments(
+ do_rescale=do_rescale,
+ rescale_factor=rescale_factor,
+ do_normalize=do_normalize,
+ image_mean=image_mean,
+ image_std=image_std,
+ do_resize=do_resize,
+ size=size,
+ resample=resample,
+ )
+
+ if annotations is not None and isinstance(annotations, dict):
+ annotations = [annotations]
+
+ if annotations is not None and len(images) != len(annotations):
+ raise ValueError(
+ f"The number of images ({len(images)}) and annotations ({len(annotations)}) do not match."
+ )
+
+ format = AnnotationFormat(format)
+ if annotations is not None:
+ validate_annotations(format, SUPPORTED_ANNOTATION_FORMATS, annotations)
+
+ if (
+ masks_path is not None
+ and format == AnnotationFormat.COCO_PANOPTIC
+ and not isinstance(masks_path, (pathlib.Path, str))
+ ):
+ raise ValueError(
+ "The path to the directory containing the mask PNG files should be provided as a"
+ f" `pathlib.Path` or string object, but is {type(masks_path)} instead."
+ )
+
+ # All transformations expect numpy arrays
+ images = [to_numpy_array(image) for image in images]
+
+ if do_rescale and is_scaled_image(images[0]):
+ logger.warning_once(
+ "It looks like you are trying to rescale already rescaled images. If the input"
+ " images have pixel values between 0 and 1, set `do_rescale=False` to avoid rescaling them again."
+ )
+
+ if input_data_format is None:
+ # We assume that all images have the same channel dimension format.
+ input_data_format = infer_channel_dimension_format(images[0])
+
+ # prepare (COCO annotations as a list of Dict -> DETR target as a single Dict per image)
+ if annotations is not None:
+ prepared_images = []
+ prepared_annotations = []
+ for image, target in zip(images, annotations):
+ target = self.prepare_annotation(
+ image,
+ target,
+ format,
+ return_segmentation_masks=return_segmentation_masks,
+ masks_path=masks_path,
+ input_data_format=input_data_format,
+ )
+ prepared_images.append(image)
+ prepared_annotations.append(target)
+ images = prepared_images
+ annotations = prepared_annotations
+ del prepared_images, prepared_annotations
+
+ # transformations
+ if do_resize:
+ if annotations is not None:
+ resized_images, resized_annotations = [], []
+ for image, target in zip(images, annotations):
+ orig_size = get_image_size(image, input_data_format)
+ resized_image = self.resize(
+ image, size=size, resample=resample, input_data_format=input_data_format
+ )
+ resized_annotation = self.resize_annotation(
+ target, orig_size, get_image_size(resized_image, input_data_format)
+ )
+ resized_images.append(resized_image)
+ resized_annotations.append(resized_annotation)
+ images = resized_images
+ annotations = resized_annotations
+ del resized_images, resized_annotations
+ else:
+ images = [
+ self.resize(image, size=size, resample=resample, input_data_format=input_data_format)
+ for image in images
+ ]
+
+ if do_rescale:
+ images = [self.rescale(image, rescale_factor, input_data_format=input_data_format) for image in images]
+
+ if do_normalize:
+ images = [
+ self.normalize(image, image_mean, image_std, input_data_format=input_data_format) for image in images
+ ]
+
+ if do_convert_annotations and annotations is not None:
+ annotations = [
+ self.normalize_annotation(annotation, get_image_size(image, input_data_format))
+ for annotation, image in zip(annotations, images)
+ ]
+
+ if do_pad:
+ # Pads images and returns their mask: {'pixel_values': ..., 'pixel_mask': ...}
+ encoded_inputs = self.pad(
+ images,
+ annotations=annotations,
+ return_pixel_mask=True,
+ data_format=data_format,
+ input_data_format=input_data_format,
+ update_bboxes=do_convert_annotations,
+ return_tensors=return_tensors,
+ pad_size=pad_size,
+ )
+ else:
+ images = [
+ to_channel_dimension_format(image, data_format, input_channel_dim=input_data_format)
+ for image in images
+ ]
+ encoded_inputs = BatchFeature(data={"pixel_values": images}, tensor_type=return_tensors)
+ if annotations is not None:
+ encoded_inputs["labels"] = [
+ BatchFeature(annotation, tensor_type=return_tensors) for annotation in annotations
+ ]
+
+ return encoded_inputs
+
+ # POSTPROCESSING METHODS - TODO: add support for other frameworks
+ def post_process(self, outputs, target_sizes):
+ """
+ Converts the raw output of [`DeformableDetrForObjectDetection`] into final bounding boxes in (top_left_x,
+ top_left_y, bottom_right_x, bottom_right_y) format. Only supports PyTorch.
+
+ Args:
+ outputs ([`DeformableDetrObjectDetectionOutput`]):
+ Raw outputs of the model.
+ target_sizes (`torch.Tensor` of shape `(batch_size, 2)`):
+ Tensor containing the size (height, width) of each image of the batch. For evaluation, this must be the
+ original image size (before any data augmentation). For visualization, this should be the image size
+ after data augment, but before padding.
+ Returns:
+ `List[Dict]`: A list of dictionaries, each dictionary containing the scores, labels and boxes for an image
+ in the batch as predicted by the model.
+ """
+ logger.warning_once(
+ "`post_process` is deprecated and will be removed in v5 of Transformers, please use"
+ " `post_process_object_detection` instead, with `threshold=0.` for equivalent results.",
+ )
+
+ out_logits, out_bbox = outputs.logits, outputs.pred_boxes
+
+ if len(out_logits) != len(target_sizes):
+ raise ValueError("Make sure that you pass in as many target sizes as the batch dimension of the logits")
+ if target_sizes.shape[1] != 2:
+ raise ValueError("Each element of target_sizes must contain the size (h, w) of each image of the batch")
+
+ prob = out_logits.sigmoid()
+ topk_values, topk_indexes = torch.topk(prob.view(out_logits.shape[0], -1), 100, dim=1)
+ scores = topk_values
+ topk_boxes = torch.div(topk_indexes, out_logits.shape[2], rounding_mode="floor")
+ labels = topk_indexes % out_logits.shape[2]
+ boxes = center_to_corners_format(out_bbox)
+ boxes = torch.gather(boxes, 1, topk_boxes.unsqueeze(-1).repeat(1, 1, 4))
+
+ # and from relative [0, 1] to absolute [0, height] coordinates
+ img_h, img_w = target_sizes.unbind(1)
+ scale_fct = torch.stack([img_w, img_h, img_w, img_h], dim=1)
+ boxes = boxes * scale_fct[:, None, :]
+
+ results = [{"scores": s, "labels": l, "boxes": b} for s, l, b in zip(scores, labels, boxes)]
+
+ return results
+
+ def post_process_object_detection(
+ self, outputs, threshold: float = 0.5, target_sizes: Union[TensorType, List[Tuple]] = None, top_k: int = 100
+ ):
+ """
+ Converts the raw output of [`DeformableDetrForObjectDetection`] into final bounding boxes in (top_left_x,
+ top_left_y, bottom_right_x, bottom_right_y) format. Only supports PyTorch.
+
+ Args:
+ outputs ([`DetrObjectDetectionOutput`]):
+ Raw outputs of the model.
+ threshold (`float`, *optional*):
+ Score threshold to keep object detection predictions.
+ target_sizes (`torch.Tensor` or `List[Tuple[int, int]]`, *optional*):
+ Tensor of shape `(batch_size, 2)` or list of tuples (`Tuple[int, int]`) containing the target size
+ (height, width) of each image in the batch. If left to None, predictions will not be resized.
+ top_k (`int`, *optional*, defaults to 100):
+ Keep only top k bounding boxes before filtering by thresholding.
+
+ Returns:
+ `List[Dict]`: A list of dictionaries, each dictionary containing the scores, labels and boxes for an image
+ in the batch as predicted by the model.
+ """
+ out_logits, out_bbox = outputs.logits, outputs.pred_boxes
+
+ if target_sizes is not None:
+ if len(out_logits) != len(target_sizes):
+ raise ValueError(
+ "Make sure that you pass in as many target sizes as the batch dimension of the logits"
+ )
+
+ prob = out_logits.sigmoid()
+ prob = prob.view(out_logits.shape[0], -1)
+ k_value = min(top_k, prob.size(1))
+ topk_values, topk_indexes = torch.topk(prob, k_value, dim=1)
+ scores = topk_values
+ topk_boxes = torch.div(topk_indexes, out_logits.shape[2], rounding_mode="floor")
+ labels = topk_indexes % out_logits.shape[2]
+ boxes = center_to_corners_format(out_bbox)
+ boxes = torch.gather(boxes, 1, topk_boxes.unsqueeze(-1).repeat(1, 1, 4))
+
+ # and from relative [0, 1] to absolute [0, height] coordinates
+ if target_sizes is not None:
+ if isinstance(target_sizes, List):
+ img_h = torch.Tensor([i[0] for i in target_sizes])
+ img_w = torch.Tensor([i[1] for i in target_sizes])
+ else:
+ img_h, img_w = target_sizes.unbind(1)
+ scale_fct = torch.stack([img_w, img_h, img_w, img_h], dim=1).to(boxes.device)
+ boxes = boxes * scale_fct[:, None, :]
+
+ results = []
+ for s, l, b in zip(scores, labels, boxes):
+ score = s[s > threshold]
+ label = l[s > threshold]
+ box = b[s > threshold]
+ results.append({"scores": score, "labels": label, "boxes": box})
+
+ return results
+
+
+__all__ = ["DeformableDetrImageProcessor"]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/image_processing_deformable_detr_fast.py b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/image_processing_deformable_detr_fast.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d400f3d139c1b54fd21a9ce92937ed16b58d98e
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/image_processing_deformable_detr_fast.py
@@ -0,0 +1,843 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/deformable_detr/modular_deformable_detr.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_deformable_detr.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+import pathlib
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from ...image_processing_utils import BatchFeature, get_size_dict
+from ...image_processing_utils_fast import (
+ BASE_IMAGE_PROCESSOR_FAST_DOCSTRING,
+ BASE_IMAGE_PROCESSOR_FAST_DOCSTRING_PREPROCESS,
+ BaseImageProcessorFast,
+ DefaultFastImageProcessorKwargs,
+ SizeDict,
+ get_image_size_for_max_height_width,
+ get_max_height_width,
+ safe_squeeze,
+)
+from ...image_transforms import center_to_corners_format, corners_to_center_format
+from ...image_utils import (
+ IMAGENET_DEFAULT_MEAN,
+ IMAGENET_DEFAULT_STD,
+ AnnotationFormat,
+ AnnotationType,
+ ChannelDimension,
+ ImageInput,
+ PILImageResampling,
+ get_image_size,
+ validate_annotations,
+)
+from ...processing_utils import Unpack
+from ...utils import (
+ TensorType,
+ add_start_docstrings,
+ is_torch_available,
+ is_torchvision_available,
+ is_torchvision_v2_available,
+ logging,
+)
+from .image_processing_deformable_detr import get_size_with_aspect_ratio
+
+
+if is_torch_available():
+ import torch
+
+
+if is_torchvision_v2_available():
+ from torchvision.io import read_image
+ from torchvision.transforms.v2 import functional as F
+elif is_torchvision_available():
+ from torchvision.io import read_image
+ from torchvision.transforms import functional as F
+
+
+logger = logging.get_logger(__name__)
+
+
+class DeformableDetrFastImageProcessorKwargs(DefaultFastImageProcessorKwargs):
+ format: Optional[Union[str, AnnotationFormat]]
+ do_convert_annotations: Optional[bool]
+ do_pad: Optional[bool]
+ pad_size: Optional[Dict[str, int]]
+ return_segmentation_masks: Optional[bool]
+
+
+SUPPORTED_ANNOTATION_FORMATS = (AnnotationFormat.COCO_DETECTION, AnnotationFormat.COCO_PANOPTIC)
+
+
+# inspired by https://github.com/facebookresearch/deformable_detr/blob/master/datasets/coco.py#L33
+def convert_coco_poly_to_mask(segmentations, height: int, width: int, device: torch.device) -> torch.Tensor:
+ """
+ Convert a COCO polygon annotation to a mask.
+
+ Args:
+ segmentations (`List[List[float]]`):
+ List of polygons, each polygon represented by a list of x-y coordinates.
+ height (`int`):
+ Height of the mask.
+ width (`int`):
+ Width of the mask.
+ """
+ try:
+ from pycocotools import mask as coco_mask
+ except ImportError:
+ raise ImportError("Pycocotools is not installed in your environment.")
+
+ masks = []
+ for polygons in segmentations:
+ rles = coco_mask.frPyObjects(polygons, height, width)
+ mask = coco_mask.decode(rles)
+ if len(mask.shape) < 3:
+ mask = mask[..., None]
+ mask = torch.as_tensor(mask, dtype=torch.uint8, device=device)
+ mask = torch.any(mask, axis=2)
+ masks.append(mask)
+ if masks:
+ masks = torch.stack(masks, axis=0)
+ else:
+ masks = torch.zeros((0, height, width), dtype=torch.uint8, device=device)
+
+ return masks
+
+
+# inspired by https://github.com/facebookresearch/deformable_detr/blob/master/datasets/coco.py#L50
+def prepare_coco_detection_annotation(
+ image,
+ target,
+ return_segmentation_masks: bool = False,
+ input_data_format: Optional[Union[ChannelDimension, str]] = None,
+):
+ """
+ Convert the target in COCO format into the format expected by DEFORMABLE_DETR.
+ """
+ image_height, image_width = image.size()[-2:]
+
+ image_id = target["image_id"]
+ image_id = torch.as_tensor([image_id], dtype=torch.int64, device=image.device)
+
+ # Get all COCO annotations for the given image.
+ annotations = target["annotations"]
+ classes = []
+ area = []
+ boxes = []
+ keypoints = []
+ for obj in annotations:
+ if "iscrowd" not in obj or obj["iscrowd"] == 0:
+ classes.append(obj["category_id"])
+ area.append(obj["area"])
+ boxes.append(obj["bbox"])
+ if "keypoints" in obj:
+ keypoints.append(obj["keypoints"])
+
+ classes = torch.as_tensor(classes, dtype=torch.int64, device=image.device)
+ area = torch.as_tensor(area, dtype=torch.float32, device=image.device)
+ iscrowd = torch.zeros_like(classes, dtype=torch.int64, device=image.device)
+ # guard against no boxes via resizing
+ boxes = torch.as_tensor(boxes, dtype=torch.float32, device=image.device).reshape(-1, 4)
+ boxes[:, 2:] += boxes[:, :2]
+ boxes[:, 0::2] = boxes[:, 0::2].clip(min=0, max=image_width)
+ boxes[:, 1::2] = boxes[:, 1::2].clip(min=0, max=image_height)
+
+ keep = (boxes[:, 3] > boxes[:, 1]) & (boxes[:, 2] > boxes[:, 0])
+
+ new_target = {
+ "image_id": image_id,
+ "class_labels": classes[keep],
+ "boxes": boxes[keep],
+ "area": area[keep],
+ "iscrowd": iscrowd[keep],
+ "orig_size": torch.as_tensor([int(image_height), int(image_width)], dtype=torch.int64, device=image.device),
+ }
+
+ if keypoints:
+ keypoints = torch.as_tensor(keypoints, dtype=torch.float32, device=image.device)
+ # Apply the keep mask here to filter the relevant annotations
+ keypoints = keypoints[keep]
+ num_keypoints = keypoints.shape[0]
+ keypoints = keypoints.reshape((-1, 3)) if num_keypoints else keypoints
+ new_target["keypoints"] = keypoints
+
+ if return_segmentation_masks:
+ segmentation_masks = [obj["segmentation"] for obj in annotations]
+ masks = convert_coco_poly_to_mask(segmentation_masks, image_height, image_width, device=image.device)
+ new_target["masks"] = masks[keep]
+
+ return new_target
+
+
+def masks_to_boxes(masks: torch.Tensor) -> torch.Tensor:
+ """
+ Compute the bounding boxes around the provided panoptic segmentation masks.
+
+ Args:
+ masks: masks in format `[number_masks, height, width]` where N is the number of masks
+
+ Returns:
+ boxes: bounding boxes in format `[number_masks, 4]` in xyxy format
+ """
+ if masks.numel() == 0:
+ return torch.zeros((0, 4), device=masks.device)
+
+ h, w = masks.shape[-2:]
+ y = torch.arange(0, h, dtype=torch.float32, device=masks.device)
+ x = torch.arange(0, w, dtype=torch.float32, device=masks.device)
+ # see https://github.com/pytorch/pytorch/issues/50276
+ y, x = torch.meshgrid(y, x, indexing="ij")
+
+ x_mask = masks * torch.unsqueeze(x, 0)
+ x_max = x_mask.view(x_mask.shape[0], -1).max(-1)[0]
+ x_min = (
+ torch.where(masks, x.unsqueeze(0), torch.tensor(1e8, device=masks.device)).view(masks.shape[0], -1).min(-1)[0]
+ )
+
+ y_mask = masks * torch.unsqueeze(y, 0)
+ y_max = y_mask.view(y_mask.shape[0], -1).max(-1)[0]
+ y_min = (
+ torch.where(masks, y.unsqueeze(0), torch.tensor(1e8, device=masks.device)).view(masks.shape[0], -1).min(-1)[0]
+ )
+
+ return torch.stack([x_min, y_min, x_max, y_max], 1)
+
+
+# 2 functions below adapted from https://github.com/cocodataset/panopticapi/blob/master/panopticapi/utils.py
+# Copyright (c) 2018, Alexander Kirillov
+# All rights reserved.
+def rgb_to_id(color):
+ """
+ Converts RGB color to unique ID.
+ """
+ if isinstance(color, torch.Tensor) and len(color.shape) == 3:
+ if color.dtype == torch.uint8:
+ color = color.to(torch.int32)
+ return color[:, :, 0] + 256 * color[:, :, 1] + 256 * 256 * color[:, :, 2]
+ return int(color[0] + 256 * color[1] + 256 * 256 * color[2])
+
+
+def prepare_coco_panoptic_annotation(
+ image: torch.Tensor,
+ target: Dict,
+ masks_path: Union[str, pathlib.Path],
+ return_masks: bool = True,
+ input_data_format: Union[ChannelDimension, str] = None,
+) -> Dict:
+ """
+ Prepare a coco panoptic annotation for DEFORMABLE_DETR.
+ """
+ image_height, image_width = get_image_size(image, channel_dim=input_data_format)
+ annotation_path = pathlib.Path(masks_path) / target["file_name"]
+
+ new_target = {}
+ new_target["image_id"] = torch.as_tensor(
+ [target["image_id"] if "image_id" in target else target["id"]], dtype=torch.int64, device=image.device
+ )
+ new_target["size"] = torch.as_tensor([image_height, image_width], dtype=torch.int64, device=image.device)
+ new_target["orig_size"] = torch.as_tensor([image_height, image_width], dtype=torch.int64, device=image.device)
+
+ if "segments_info" in target:
+ masks = read_image(annotation_path).permute(1, 2, 0).to(torch.int32).to(image.device)
+ masks = rgb_to_id(masks)
+
+ ids = torch.as_tensor([segment_info["id"] for segment_info in target["segments_info"]], device=image.device)
+ masks = masks == ids[:, None, None]
+ masks = masks.to(torch.bool)
+ if return_masks:
+ new_target["masks"] = masks
+ new_target["boxes"] = masks_to_boxes(masks)
+ new_target["class_labels"] = torch.as_tensor(
+ [segment_info["category_id"] for segment_info in target["segments_info"]],
+ dtype=torch.int64,
+ device=image.device,
+ )
+ new_target["iscrowd"] = torch.as_tensor(
+ [segment_info["iscrowd"] for segment_info in target["segments_info"]],
+ dtype=torch.int64,
+ device=image.device,
+ )
+ new_target["area"] = torch.as_tensor(
+ [segment_info["area"] for segment_info in target["segments_info"]],
+ dtype=torch.float32,
+ device=image.device,
+ )
+
+ return new_target
+
+
+@add_start_docstrings(
+ "Constructs a fast DeformableDetr image processor.",
+ BASE_IMAGE_PROCESSOR_FAST_DOCSTRING,
+ """
+ format (`str`, *optional*, defaults to `AnnotationFormat.COCO_DETECTION`):
+ Data format of the annotations. One of "coco_detection" or "coco_panoptic".
+ do_convert_annotations (`bool`, *optional*, defaults to `True`):
+ Controls whether to convert the annotations to the format expected by the DEFORMABLE_DETR model. Converts the
+ bounding boxes to the format `(center_x, center_y, width, height)` and in the range `[0, 1]`.
+ Can be overridden by the `do_convert_annotations` parameter in the `preprocess` method.
+ do_pad (`bool`, *optional*, defaults to `True`):
+ Controls whether to pad the image. Can be overridden by the `do_pad` parameter in the `preprocess`
+ method. If `True`, padding will be applied to the bottom and right of the image with zeros.
+ If `pad_size` is provided, the image will be padded to the specified dimensions.
+ Otherwise, the image will be padded to the maximum height and width of the batch.
+ pad_size (`Dict[str, int]`, *optional*):
+ The size `{"height": int, "width" int}` to pad the images to. Must be larger than any image size
+ provided for preprocessing. If `pad_size` is not provided, images will be padded to the largest
+ height and width in the batch.
+ return_segmentation_masks (`bool`, *optional*, defaults to `False`):
+ Whether to return segmentation masks.
+ """,
+)
+class DeformableDetrImageProcessorFast(BaseImageProcessorFast):
+ resample = PILImageResampling.BILINEAR
+ image_mean = IMAGENET_DEFAULT_MEAN
+ image_std = IMAGENET_DEFAULT_STD
+ format = AnnotationFormat.COCO_DETECTION
+ do_resize = True
+ do_rescale = True
+ do_normalize = True
+ do_pad = True
+ size = {"shortest_edge": 800, "longest_edge": 1333}
+ default_to_square = False
+ model_input_names = ["pixel_values", "pixel_mask"]
+ valid_kwargs = DeformableDetrFastImageProcessorKwargs
+
+ def __init__(self, **kwargs: Unpack[DeformableDetrFastImageProcessorKwargs]) -> None:
+ if "pad_and_return_pixel_mask" in kwargs:
+ kwargs["do_pad"] = kwargs.pop("pad_and_return_pixel_mask")
+
+ size = kwargs.pop("size", None)
+ if "max_size" in kwargs:
+ logger.warning_once(
+ "The `max_size` parameter is deprecated and will be removed in v4.26. "
+ "Please specify in `size['longest_edge'] instead`.",
+ )
+ max_size = kwargs.pop("max_size")
+ else:
+ max_size = None if size is None else 1333
+
+ size = size if size is not None else {"shortest_edge": 800, "longest_edge": 1333}
+ self.size = get_size_dict(size, max_size=max_size, default_to_square=False)
+
+ # Backwards compatibility
+ do_convert_annotations = kwargs.get("do_convert_annotations", None)
+ do_normalize = kwargs.get("do_normalize", None)
+ if do_convert_annotations is None and getattr(self, "do_convert_annotations", None) is None:
+ self.do_convert_annotations = do_normalize if do_normalize is not None else self.do_normalize
+
+ super().__init__(**kwargs)
+
+ @classmethod
+ def from_dict(cls, image_processor_dict: Dict[str, Any], **kwargs):
+ """
+ Overrides the `from_dict` method from the base class to make sure parameters are updated if image processor is
+ created using from_dict and kwargs e.g. `DeformableDetrImageProcessorFast.from_pretrained(checkpoint, size=600,
+ max_size=800)`
+ """
+ image_processor_dict = image_processor_dict.copy()
+ if "max_size" in kwargs:
+ image_processor_dict["max_size"] = kwargs.pop("max_size")
+ if "pad_and_return_pixel_mask" in kwargs:
+ image_processor_dict["pad_and_return_pixel_mask"] = kwargs.pop("pad_and_return_pixel_mask")
+ return super().from_dict(image_processor_dict, **kwargs)
+
+ def prepare_annotation(
+ self,
+ image: torch.Tensor,
+ target: Dict,
+ format: Optional[AnnotationFormat] = None,
+ return_segmentation_masks: bool = None,
+ masks_path: Optional[Union[str, pathlib.Path]] = None,
+ input_data_format: Optional[Union[str, ChannelDimension]] = None,
+ ) -> Dict:
+ """
+ Prepare an annotation for feeding into DEFORMABLE_DETR model.
+ """
+ format = format if format is not None else self.format
+
+ if format == AnnotationFormat.COCO_DETECTION:
+ return_segmentation_masks = False if return_segmentation_masks is None else return_segmentation_masks
+ target = prepare_coco_detection_annotation(
+ image, target, return_segmentation_masks, input_data_format=input_data_format
+ )
+ elif format == AnnotationFormat.COCO_PANOPTIC:
+ return_segmentation_masks = True if return_segmentation_masks is None else return_segmentation_masks
+ target = prepare_coco_panoptic_annotation(
+ image,
+ target,
+ masks_path=masks_path,
+ return_masks=return_segmentation_masks,
+ input_data_format=input_data_format,
+ )
+ else:
+ raise ValueError(f"Format {format} is not supported.")
+ return target
+
+ def resize(
+ self,
+ image: torch.Tensor,
+ size: SizeDict,
+ interpolation: "F.InterpolationMode" = None,
+ **kwargs,
+ ) -> torch.Tensor:
+ """
+ Resize the image to the given size. Size can be `min_size` (scalar) or `(height, width)` tuple. If size is an
+ int, smaller edge of the image will be matched to this number.
+
+ Args:
+ image (`torch.Tensor`):
+ Image to resize.
+ size (`SizeDict`):
+ Size of the image's `(height, width)` dimensions after resizing. Available options are:
+ - `{"height": int, "width": int}`: The image will be resized to the exact size `(height, width)`.
+ Do NOT keep the aspect ratio.
+ - `{"shortest_edge": int, "longest_edge": int}`: The image will be resized to a maximum size respecting
+ the aspect ratio and keeping the shortest edge less or equal to `shortest_edge` and the longest edge
+ less or equal to `longest_edge`.
+ - `{"max_height": int, "max_width": int}`: The image will be resized to the maximum size respecting the
+ aspect ratio and keeping the height less or equal to `max_height` and the width less or equal to
+ `max_width`.
+ interpolation (`InterpolationMode`, *optional*, defaults to `InterpolationMode.BILINEAR`):
+ Resampling filter to use if resizing the image.
+ """
+ interpolation = interpolation if interpolation is not None else F.InterpolationMode.BILINEAR
+ if size.shortest_edge and size.longest_edge:
+ # Resize the image so that the shortest edge or the longest edge is of the given size
+ # while maintaining the aspect ratio of the original image.
+ new_size = get_size_with_aspect_ratio(
+ image.size()[-2:],
+ size["shortest_edge"],
+ size["longest_edge"],
+ )
+ elif size.max_height and size.max_width:
+ new_size = get_image_size_for_max_height_width(image.size()[-2:], size["max_height"], size["max_width"])
+ elif size.height and size.width:
+ new_size = (size["height"], size["width"])
+ else:
+ raise ValueError(
+ "Size must contain 'height' and 'width' keys or 'shortest_edge' and 'longest_edge' keys. Got"
+ f" {size.keys()}."
+ )
+
+ image = F.resize(
+ image,
+ size=new_size,
+ interpolation=interpolation,
+ **kwargs,
+ )
+ return image
+
+ def resize_annotation(
+ self,
+ annotation: Dict[str, Any],
+ orig_size: Tuple[int, int],
+ target_size: Tuple[int, int],
+ threshold: float = 0.5,
+ interpolation: "F.InterpolationMode" = None,
+ ):
+ """
+ Resizes an annotation to a target size.
+
+ Args:
+ annotation (`Dict[str, Any]`):
+ The annotation dictionary.
+ orig_size (`Tuple[int, int]`):
+ The original size of the input image.
+ target_size (`Tuple[int, int]`):
+ The target size of the image, as returned by the preprocessing `resize` step.
+ threshold (`float`, *optional*, defaults to 0.5):
+ The threshold used to binarize the segmentation masks.
+ resample (`InterpolationMode`, defaults to `InterpolationMode.NEAREST`):
+ The resampling filter to use when resizing the masks.
+ """
+ interpolation = interpolation if interpolation is not None else F.InterpolationMode.NEAREST
+ ratio_height, ratio_width = [target / orig for target, orig in zip(target_size, orig_size)]
+
+ new_annotation = {}
+ new_annotation["size"] = target_size
+
+ for key, value in annotation.items():
+ if key == "boxes":
+ boxes = value
+ scaled_boxes = boxes * torch.as_tensor(
+ [ratio_width, ratio_height, ratio_width, ratio_height], dtype=torch.float32, device=boxes.device
+ )
+ new_annotation["boxes"] = scaled_boxes
+ elif key == "area":
+ area = value
+ scaled_area = area * (ratio_width * ratio_height)
+ new_annotation["area"] = scaled_area
+ elif key == "masks":
+ masks = value[:, None]
+ masks = [F.resize(mask, target_size, interpolation=interpolation) for mask in masks]
+ masks = torch.stack(masks).to(torch.float32)
+ masks = masks[:, 0] > threshold
+ new_annotation["masks"] = masks
+ elif key == "size":
+ new_annotation["size"] = target_size
+ else:
+ new_annotation[key] = value
+
+ return new_annotation
+
+ def normalize_annotation(self, annotation: Dict, image_size: Tuple[int, int]) -> Dict:
+ image_height, image_width = image_size
+ norm_annotation = {}
+ for key, value in annotation.items():
+ if key == "boxes":
+ boxes = value
+ boxes = corners_to_center_format(boxes)
+ boxes /= torch.as_tensor(
+ [image_width, image_height, image_width, image_height], dtype=torch.float32, device=boxes.device
+ )
+ norm_annotation[key] = boxes
+ else:
+ norm_annotation[key] = value
+ return norm_annotation
+
+ def _update_annotation_for_padded_image(
+ self,
+ annotation: Dict,
+ input_image_size: Tuple[int, int],
+ output_image_size: Tuple[int, int],
+ padding,
+ update_bboxes,
+ ) -> Dict:
+ """
+ Update the annotation for a padded image.
+ """
+ new_annotation = {}
+ new_annotation["size"] = output_image_size
+ ratio_height, ratio_width = (input / output for output, input in zip(output_image_size, input_image_size))
+
+ for key, value in annotation.items():
+ if key == "masks":
+ masks = value
+ masks = F.pad(
+ masks,
+ padding,
+ fill=0,
+ )
+ masks = safe_squeeze(masks, 1)
+ new_annotation["masks"] = masks
+ elif key == "boxes" and update_bboxes:
+ boxes = value
+ boxes *= torch.as_tensor([ratio_width, ratio_height, ratio_width, ratio_height], device=boxes.device)
+ new_annotation["boxes"] = boxes
+ elif key == "size":
+ new_annotation["size"] = output_image_size
+ else:
+ new_annotation[key] = value
+ return new_annotation
+
+ def pad(
+ self,
+ image: torch.Tensor,
+ padded_size: Tuple[int, int],
+ annotation: Optional[Dict[str, Any]] = None,
+ update_bboxes: bool = True,
+ fill: int = 0,
+ ):
+ original_size = image.size()[-2:]
+ padding_bottom = padded_size[0] - original_size[0]
+ padding_right = padded_size[1] - original_size[1]
+ if padding_bottom < 0 or padding_right < 0:
+ raise ValueError(
+ f"Padding dimensions are negative. Please make sure that the padded size is larger than the "
+ f"original size. Got padded size: {padded_size}, original size: {original_size}."
+ )
+ if original_size != padded_size:
+ padding = [0, 0, padding_right, padding_bottom]
+ image = F.pad(image, padding, fill=fill)
+ if annotation is not None:
+ annotation = self._update_annotation_for_padded_image(
+ annotation, original_size, padded_size, padding, update_bboxes
+ )
+
+ # Make a pixel mask for the image, where 1 indicates a valid pixel and 0 indicates padding.
+ pixel_mask = torch.zeros(padded_size, dtype=torch.int64, device=image.device)
+ pixel_mask[: original_size[0], : original_size[1]] = 1
+
+ return image, pixel_mask, annotation
+
+ @add_start_docstrings(
+ BASE_IMAGE_PROCESSOR_FAST_DOCSTRING_PREPROCESS,
+ """
+ annotations (`AnnotationType` or `List[AnnotationType]`, *optional*):
+ List of annotations associated with the image or batch of images. If annotation is for object
+ detection, the annotations should be a dictionary with the following keys:
+ - "image_id" (`int`): The image id.
+ - "annotations" (`List[Dict]`): List of annotations for an image. Each annotation should be a
+ dictionary. An image can have no annotations, in which case the list should be empty.
+ If annotation is for segmentation, the annotations should be a dictionary with the following keys:
+ - "image_id" (`int`): The image id.
+ - "segments_info" (`List[Dict]`): List of segments for an image. Each segment should be a dictionary.
+ An image can have no segments, in which case the list should be empty.
+ - "file_name" (`str`): The file name of the image.
+ format (`str`, *optional*, defaults to `AnnotationFormat.COCO_DETECTION`):
+ Data format of the annotations. One of "coco_detection" or "coco_panoptic".
+ do_convert_annotations (`bool`, *optional*, defaults to `True`):
+ Controls whether to convert the annotations to the format expected by the DEFORMABLE_DETR model. Converts the
+ bounding boxes to the format `(center_x, center_y, width, height)` and in the range `[0, 1]`.
+ Can be overridden by the `do_convert_annotations` parameter in the `preprocess` method.
+ do_pad (`bool`, *optional*, defaults to `True`):
+ Controls whether to pad the image. Can be overridden by the `do_pad` parameter in the `preprocess`
+ method. If `True`, padding will be applied to the bottom and right of the image with zeros.
+ If `pad_size` is provided, the image will be padded to the specified dimensions.
+ Otherwise, the image will be padded to the maximum height and width of the batch.
+ pad_size (`Dict[str, int]`, *optional*):
+ The size `{"height": int, "width" int}` to pad the images to. Must be larger than any image size
+ provided for preprocessing. If `pad_size` is not provided, images will be padded to the largest
+ height and width in the batch.
+ return_segmentation_masks (`bool`, *optional*, defaults to `False`):
+ Whether to return segmentation masks.
+ masks_path (`str` or `pathlib.Path`, *optional*):
+ Path to the directory containing the segmentation masks.
+ """,
+ )
+ def preprocess(
+ self,
+ images: ImageInput,
+ annotations: Optional[Union[AnnotationType, List[AnnotationType]]] = None,
+ masks_path: Optional[Union[str, pathlib.Path]] = None,
+ **kwargs: Unpack[DeformableDetrFastImageProcessorKwargs],
+ ) -> BatchFeature:
+ if "pad_and_return_pixel_mask" in kwargs:
+ kwargs["do_pad"] = kwargs.pop("pad_and_return_pixel_mask")
+ logger.warning_once(
+ "The `pad_and_return_pixel_mask` argument is deprecated and will be removed in a future version, "
+ "use `do_pad` instead."
+ )
+
+ if "max_size" in kwargs:
+ logger.warning_once(
+ "The `max_size` argument is deprecated and will be removed in a future version, use"
+ " `size['longest_edge']` instead."
+ )
+ kwargs["size"] = kwargs.pop("max_size")
+
+ return super().preprocess(images, annotations=annotations, masks_path=masks_path, **kwargs)
+
+ def _preprocess(
+ self,
+ images: List["torch.Tensor"],
+ annotations: Optional[Union[AnnotationType, List[AnnotationType]]],
+ return_segmentation_masks: bool,
+ masks_path: Optional[Union[str, pathlib.Path]],
+ do_resize: bool,
+ size: SizeDict,
+ interpolation: Optional["F.InterpolationMode"],
+ do_center_crop: bool,
+ crop_size: SizeDict,
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ do_convert_annotations: bool,
+ image_mean: Optional[Union[float, List[float]]],
+ image_std: Optional[Union[float, List[float]]],
+ do_pad: bool,
+ pad_size: Optional[Dict[str, int]],
+ format: Optional[Union[str, AnnotationFormat]],
+ return_tensors: Optional[Union[str, TensorType]],
+ ) -> BatchFeature:
+ """
+ Preprocess an image or a batch of images so that it can be used by the model.
+ """
+ if annotations is not None and isinstance(annotations, dict):
+ annotations = [annotations]
+
+ if annotations is not None and len(images) != len(annotations):
+ raise ValueError(
+ f"The number of images ({len(images)}) and annotations ({len(annotations)}) do not match."
+ )
+
+ format = AnnotationFormat(format)
+ if annotations is not None:
+ validate_annotations(format, SUPPORTED_ANNOTATION_FORMATS, annotations)
+
+ if (
+ masks_path is not None
+ and format == AnnotationFormat.COCO_PANOPTIC
+ and not isinstance(masks_path, (pathlib.Path, str))
+ ):
+ raise ValueError(
+ "The path to the directory containing the mask PNG files should be provided as a"
+ f" `pathlib.Path` or string object, but is {type(masks_path)} instead."
+ )
+
+ data = {}
+
+ processed_images = []
+ processed_annotations = []
+ pixel_masks = [] # Initialize pixel_masks here
+ for image, annotation in zip(images, annotations if annotations is not None else [None] * len(images)):
+ # prepare (COCO annotations as a list of Dict -> DEFORMABLE_DETR target as a single Dict per image)
+ if annotations is not None:
+ annotation = self.prepare_annotation(
+ image,
+ annotation,
+ format,
+ return_segmentation_masks=return_segmentation_masks,
+ masks_path=masks_path,
+ input_data_format=ChannelDimension.FIRST,
+ )
+
+ if do_resize:
+ resized_image = self.resize(image, size=size, interpolation=interpolation)
+ if annotations is not None:
+ annotation = self.resize_annotation(
+ annotation,
+ orig_size=image.size()[-2:],
+ target_size=resized_image.size()[-2:],
+ )
+ image = resized_image
+ # Fused rescale and normalize
+ image = self.rescale_and_normalize(image, do_rescale, rescale_factor, do_normalize, image_mean, image_std)
+ if do_convert_annotations and annotations is not None:
+ annotation = self.normalize_annotation(annotation, get_image_size(image, ChannelDimension.FIRST))
+
+ processed_images.append(image)
+ processed_annotations.append(annotation)
+ images = processed_images
+ annotations = processed_annotations if annotations is not None else None
+
+ if do_pad:
+ # depends on all resized image shapes so we need another loop
+ if pad_size is not None:
+ padded_size = (pad_size["height"], pad_size["width"])
+ else:
+ padded_size = get_max_height_width(images)
+
+ padded_images = []
+ padded_annotations = []
+ for image, annotation in zip(images, annotations if annotations is not None else [None] * len(images)):
+ # Pads images and returns their mask: {'pixel_values': ..., 'pixel_mask': ...}
+ if padded_size == image.size()[-2:]:
+ padded_images.append(image)
+ pixel_masks.append(torch.ones(padded_size, dtype=torch.int64, device=image.device))
+ padded_annotations.append(annotation)
+ continue
+ image, pixel_mask, annotation = self.pad(
+ image, padded_size, annotation=annotation, update_bboxes=do_convert_annotations
+ )
+ padded_images.append(image)
+ padded_annotations.append(annotation)
+ pixel_masks.append(pixel_mask)
+ images = padded_images
+ annotations = padded_annotations if annotations is not None else None
+ data.update({"pixel_mask": torch.stack(pixel_masks, dim=0)})
+
+ data.update({"pixel_values": torch.stack(images, dim=0)})
+ encoded_inputs = BatchFeature(data, tensor_type=return_tensors)
+ if annotations is not None:
+ encoded_inputs["labels"] = [
+ BatchFeature(annotation, tensor_type=return_tensors) for annotation in annotations
+ ]
+ return encoded_inputs
+
+ def post_process(self, outputs, target_sizes):
+ """
+ Converts the raw output of [`DeformableDetrForObjectDetection`] into final bounding boxes in (top_left_x,
+ top_left_y, bottom_right_x, bottom_right_y) format. Only supports PyTorch.
+
+ Args:
+ outputs ([`DeformableDetrObjectDetectionOutput`]):
+ Raw outputs of the model.
+ target_sizes (`torch.Tensor` of shape `(batch_size, 2)`):
+ Tensor containing the size (height, width) of each image of the batch. For evaluation, this must be the
+ original image size (before any data augmentation). For visualization, this should be the image size
+ after data augment, but before padding.
+ Returns:
+ `List[Dict]`: A list of dictionaries, each dictionary containing the scores, labels and boxes for an image
+ in the batch as predicted by the model.
+ """
+ logger.warning_once(
+ "`post_process` is deprecated and will be removed in v5 of Transformers, please use"
+ " `post_process_object_detection` instead, with `threshold=0.` for equivalent results.",
+ )
+
+ out_logits, out_bbox = outputs.logits, outputs.pred_boxes
+
+ if len(out_logits) != len(target_sizes):
+ raise ValueError("Make sure that you pass in as many target sizes as the batch dimension of the logits")
+ if target_sizes.shape[1] != 2:
+ raise ValueError("Each element of target_sizes must contain the size (h, w) of each image of the batch")
+
+ prob = out_logits.sigmoid()
+ topk_values, topk_indexes = torch.topk(prob.view(out_logits.shape[0], -1), 100, dim=1)
+ scores = topk_values
+ topk_boxes = torch.div(topk_indexes, out_logits.shape[2], rounding_mode="floor")
+ labels = topk_indexes % out_logits.shape[2]
+ boxes = center_to_corners_format(out_bbox)
+ boxes = torch.gather(boxes, 1, topk_boxes.unsqueeze(-1).repeat(1, 1, 4))
+
+ # and from relative [0, 1] to absolute [0, height] coordinates
+ img_h, img_w = target_sizes.unbind(1)
+ scale_fct = torch.stack([img_w, img_h, img_w, img_h], dim=1)
+ boxes = boxes * scale_fct[:, None, :]
+
+ results = [{"scores": s, "labels": l, "boxes": b} for s, l, b in zip(scores, labels, boxes)]
+
+ return results
+
+ def post_process_object_detection(
+ self, outputs, threshold: float = 0.5, target_sizes: Union[TensorType, List[Tuple]] = None, top_k: int = 100
+ ):
+ """
+ Converts the raw output of [`DeformableDetrForObjectDetection`] into final bounding boxes in (top_left_x,
+ top_left_y, bottom_right_x, bottom_right_y) format. Only supports PyTorch.
+
+ Args:
+ outputs ([`DetrObjectDetectionOutput`]):
+ Raw outputs of the model.
+ threshold (`float`, *optional*):
+ Score threshold to keep object detection predictions.
+ target_sizes (`torch.Tensor` or `List[Tuple[int, int]]`, *optional*):
+ Tensor of shape `(batch_size, 2)` or list of tuples (`Tuple[int, int]`) containing the target size
+ (height, width) of each image in the batch. If left to None, predictions will not be resized.
+ top_k (`int`, *optional*, defaults to 100):
+ Keep only top k bounding boxes before filtering by thresholding.
+
+ Returns:
+ `List[Dict]`: A list of dictionaries, each dictionary containing the scores, labels and boxes for an image
+ in the batch as predicted by the model.
+ """
+ out_logits, out_bbox = outputs.logits, outputs.pred_boxes
+
+ if target_sizes is not None:
+ if len(out_logits) != len(target_sizes):
+ raise ValueError(
+ "Make sure that you pass in as many target sizes as the batch dimension of the logits"
+ )
+
+ prob = out_logits.sigmoid()
+ prob = prob.view(out_logits.shape[0], -1)
+ k_value = min(top_k, prob.size(1))
+ topk_values, topk_indexes = torch.topk(prob, k_value, dim=1)
+ scores = topk_values
+ topk_boxes = torch.div(topk_indexes, out_logits.shape[2], rounding_mode="floor")
+ labels = topk_indexes % out_logits.shape[2]
+ boxes = center_to_corners_format(out_bbox)
+ boxes = torch.gather(boxes, 1, topk_boxes.unsqueeze(-1).repeat(1, 1, 4))
+
+ # and from relative [0, 1] to absolute [0, height] coordinates
+ if target_sizes is not None:
+ if isinstance(target_sizes, List):
+ img_h = torch.Tensor([i[0] for i in target_sizes])
+ img_w = torch.Tensor([i[1] for i in target_sizes])
+ else:
+ img_h, img_w = target_sizes.unbind(1)
+ scale_fct = torch.stack([img_w, img_h, img_w, img_h], dim=1).to(boxes.device)
+ boxes = boxes * scale_fct[:, None, :]
+
+ results = []
+ for s, l, b in zip(scores, labels, boxes):
+ score = s[s > threshold]
+ label = l[s > threshold]
+ box = b[s > threshold]
+ results.append({"scores": score, "labels": label, "boxes": box})
+
+ return results
+
+
+__all__ = ["DeformableDetrImageProcessorFast"]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/modeling_deformable_detr.py b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/modeling_deformable_detr.py
new file mode 100644
index 0000000000000000000000000000000000000000..8db75abc0a772c545f1fe3bca2a7917616f3f9e2
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/modeling_deformable_detr.py
@@ -0,0 +1,2030 @@
+# coding=utf-8
+# Copyright 2022 SenseTime and The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""PyTorch Deformable DETR model."""
+
+import copy
+import math
+import warnings
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple, Union
+
+import torch
+import torch.nn.functional as F
+from torch import Tensor, nn
+
+from ...activations import ACT2FN
+from ...integrations import use_kernel_forward_from_hub
+from ...modeling_attn_mask_utils import _prepare_4d_attention_mask
+from ...modeling_outputs import BaseModelOutput
+from ...modeling_utils import PreTrainedModel
+from ...pytorch_utils import meshgrid
+from ...utils import (
+ ModelOutput,
+ add_start_docstrings,
+ add_start_docstrings_to_model_forward,
+ is_timm_available,
+ logging,
+ replace_return_docstrings,
+ requires_backends,
+)
+from ...utils.backbone_utils import load_backbone
+from .configuration_deformable_detr import DeformableDetrConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+if is_timm_available():
+ from timm import create_model
+
+
+logger = logging.get_logger(__name__)
+
+_CONFIG_FOR_DOC = "DeformableDetrConfig"
+_CHECKPOINT_FOR_DOC = "sensetime/deformable-detr"
+
+
+@use_kernel_forward_from_hub("MultiScaleDeformableAttention")
+class MultiScaleDeformableAttention(nn.Module):
+ def forward(
+ self,
+ value: Tensor,
+ value_spatial_shapes: Tensor,
+ value_spatial_shapes_list: List[Tuple],
+ level_start_index: Tensor,
+ sampling_locations: Tensor,
+ attention_weights: Tensor,
+ im2col_step: int,
+ ):
+ batch_size, _, num_heads, hidden_dim = value.shape
+ _, num_queries, num_heads, num_levels, num_points, _ = sampling_locations.shape
+ value_list = value.split([height * width for height, width in value_spatial_shapes_list], dim=1)
+ sampling_grids = 2 * sampling_locations - 1
+ sampling_value_list = []
+ for level_id, (height, width) in enumerate(value_spatial_shapes_list):
+ # batch_size, height*width, num_heads, hidden_dim
+ # -> batch_size, height*width, num_heads*hidden_dim
+ # -> batch_size, num_heads*hidden_dim, height*width
+ # -> batch_size*num_heads, hidden_dim, height, width
+ value_l_ = (
+ value_list[level_id]
+ .flatten(2)
+ .transpose(1, 2)
+ .reshape(batch_size * num_heads, hidden_dim, height, width)
+ )
+ # batch_size, num_queries, num_heads, num_points, 2
+ # -> batch_size, num_heads, num_queries, num_points, 2
+ # -> batch_size*num_heads, num_queries, num_points, 2
+ sampling_grid_l_ = sampling_grids[:, :, :, level_id].transpose(1, 2).flatten(0, 1)
+ # batch_size*num_heads, hidden_dim, num_queries, num_points
+ sampling_value_l_ = nn.functional.grid_sample(
+ value_l_,
+ sampling_grid_l_,
+ mode="bilinear",
+ padding_mode="zeros",
+ align_corners=False,
+ )
+ sampling_value_list.append(sampling_value_l_)
+ # (batch_size, num_queries, num_heads, num_levels, num_points)
+ # -> (batch_size, num_heads, num_queries, num_levels, num_points)
+ # -> (batch_size, num_heads, 1, num_queries, num_levels*num_points)
+ attention_weights = attention_weights.transpose(1, 2).reshape(
+ batch_size * num_heads, 1, num_queries, num_levels * num_points
+ )
+ output = (
+ (torch.stack(sampling_value_list, dim=-2).flatten(-2) * attention_weights)
+ .sum(-1)
+ .view(batch_size, num_heads * hidden_dim, num_queries)
+ )
+ return output.transpose(1, 2).contiguous()
+
+
+@dataclass
+class DeformableDetrDecoderOutput(ModelOutput):
+ """
+ Base class for outputs of the DeformableDetrDecoder. This class adds two attributes to
+ BaseModelOutputWithCrossAttentions, namely:
+ - a stacked tensor of intermediate decoder hidden states (i.e. the output of each decoder layer)
+ - a stacked tensor of intermediate reference points.
+
+ Args:
+ last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+ Sequence of hidden-states at the output of the last layer of the model.
+ intermediate_hidden_states (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, num_queries, hidden_size)`):
+ Stacked intermediate hidden states (output of each layer of the decoder).
+ intermediate_reference_points (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, sequence_length, hidden_size)`):
+ Stacked intermediate reference points (reference points of each layer of the decoder).
+ hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer) of
+ shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the model at the output of each layer
+ plus the initial embedding outputs.
+ attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+ sequence_length)`. Attentions weights after the attention softmax, used to compute the weighted average in
+ the self-attention heads.
+ cross_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` and `config.add_cross_attention=True` is passed or when `config.output_attentions=True`):
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+ sequence_length)`. Attentions weights of the decoder's cross-attention layer, after the attention softmax,
+ used to compute the weighted average in the cross-attention heads.
+ """
+
+ last_hidden_state: torch.FloatTensor = None
+ intermediate_hidden_states: torch.FloatTensor = None
+ intermediate_reference_points: torch.FloatTensor = None
+ hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+ attentions: Optional[Tuple[torch.FloatTensor]] = None
+ cross_attentions: Optional[Tuple[torch.FloatTensor]] = None
+
+
+@dataclass
+class DeformableDetrModelOutput(ModelOutput):
+ """
+ Base class for outputs of the Deformable DETR encoder-decoder model.
+
+ Args:
+ init_reference_points (`torch.FloatTensor` of shape `(batch_size, num_queries, 4)`):
+ Initial reference points sent through the Transformer decoder.
+ last_hidden_state (`torch.FloatTensor` of shape `(batch_size, num_queries, hidden_size)`):
+ Sequence of hidden-states at the output of the last layer of the decoder of the model.
+ intermediate_hidden_states (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, num_queries, hidden_size)`):
+ Stacked intermediate hidden states (output of each layer of the decoder).
+ intermediate_reference_points (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, num_queries, 4)`):
+ Stacked intermediate reference points (reference points of each layer of the decoder).
+ decoder_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer) of
+ shape `(batch_size, num_queries, hidden_size)`. Hidden-states of the decoder at the output of each layer
+ plus the initial embedding outputs.
+ decoder_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, num_queries,
+ num_queries)`. Attentions weights of the decoder, after the attention softmax, used to compute the weighted
+ average in the self-attention heads.
+ cross_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_queries, num_heads, 4, 4)`.
+ Attentions weights of the decoder's cross-attention layer, after the attention softmax, used to compute the
+ weighted average in the cross-attention heads.
+ encoder_last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+ Sequence of hidden-states at the output of the last layer of the encoder of the model.
+ encoder_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer) of
+ shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the encoder at the output of each
+ layer plus the initial embedding outputs.
+ encoder_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_queries, num_heads, 4, 4)`.
+ Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
+ self-attention heads.
+ enc_outputs_class (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.num_labels)`, *optional*, returned when `config.with_box_refine=True` and `config.two_stage=True`):
+ Predicted bounding boxes scores where the top `config.two_stage_num_proposals` scoring bounding boxes are
+ picked as region proposals in the first stage. Output of bounding box binary classification (i.e.
+ foreground and background).
+ enc_outputs_coord_logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, 4)`, *optional*, returned when `config.with_box_refine=True` and `config.two_stage=True`):
+ Logits of predicted bounding boxes coordinates in the first stage.
+ """
+
+ init_reference_points: torch.FloatTensor = None
+ last_hidden_state: torch.FloatTensor = None
+ intermediate_hidden_states: torch.FloatTensor = None
+ intermediate_reference_points: torch.FloatTensor = None
+ decoder_hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+ decoder_attentions: Optional[Tuple[torch.FloatTensor]] = None
+ cross_attentions: Optional[Tuple[torch.FloatTensor]] = None
+ encoder_last_hidden_state: Optional[torch.FloatTensor] = None
+ encoder_hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+ encoder_attentions: Optional[Tuple[torch.FloatTensor]] = None
+ enc_outputs_class: Optional[torch.FloatTensor] = None
+ enc_outputs_coord_logits: Optional[torch.FloatTensor] = None
+
+
+@dataclass
+class DeformableDetrObjectDetectionOutput(ModelOutput):
+ """
+ Output type of [`DeformableDetrForObjectDetection`].
+
+ Args:
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` are provided)):
+ Total loss as a linear combination of a negative log-likehood (cross-entropy) for class prediction and a
+ bounding box loss. The latter is defined as a linear combination of the L1 loss and the generalized
+ scale-invariant IoU loss.
+ loss_dict (`Dict`, *optional*):
+ A dictionary containing the individual losses. Useful for logging.
+ logits (`torch.FloatTensor` of shape `(batch_size, num_queries, num_classes + 1)`):
+ Classification logits (including no-object) for all queries.
+ pred_boxes (`torch.FloatTensor` of shape `(batch_size, num_queries, 4)`):
+ Normalized boxes coordinates for all queries, represented as (center_x, center_y, width, height). These
+ values are normalized in [0, 1], relative to the size of each individual image in the batch (disregarding
+ possible padding). You can use [`~DeformableDetrProcessor.post_process_object_detection`] to retrieve the
+ unnormalized bounding boxes.
+ auxiliary_outputs (`list[Dict]`, *optional*):
+ Optional, only returned when auxilary losses are activated (i.e. `config.auxiliary_loss` is set to `True`)
+ and labels are provided. It is a list of dictionaries containing the two above keys (`logits` and
+ `pred_boxes`) for each decoder layer.
+ last_hidden_state (`torch.FloatTensor` of shape `(batch_size, num_queries, hidden_size)`, *optional*):
+ Sequence of hidden-states at the output of the last layer of the decoder of the model.
+ decoder_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer) of
+ shape `(batch_size, num_queries, hidden_size)`. Hidden-states of the decoder at the output of each layer
+ plus the initial embedding outputs.
+ decoder_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, num_queries,
+ num_queries)`. Attentions weights of the decoder, after the attention softmax, used to compute the weighted
+ average in the self-attention heads.
+ cross_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_queries, num_heads, 4, 4)`.
+ Attentions weights of the decoder's cross-attention layer, after the attention softmax, used to compute the
+ weighted average in the cross-attention heads.
+ encoder_last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+ Sequence of hidden-states at the output of the last layer of the encoder of the model.
+ encoder_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer) of
+ shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the encoder at the output of each
+ layer plus the initial embedding outputs.
+ encoder_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, sequence_length, num_heads, 4,
+ 4)`. Attentions weights of the encoder, after the attention softmax, used to compute the weighted average
+ in the self-attention heads.
+ intermediate_hidden_states (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, num_queries, hidden_size)`):
+ Stacked intermediate hidden states (output of each layer of the decoder).
+ intermediate_reference_points (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, num_queries, 4)`):
+ Stacked intermediate reference points (reference points of each layer of the decoder).
+ init_reference_points (`torch.FloatTensor` of shape `(batch_size, num_queries, 4)`):
+ Initial reference points sent through the Transformer decoder.
+ enc_outputs_class (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.num_labels)`, *optional*, returned when `config.with_box_refine=True` and `config.two_stage=True`):
+ Predicted bounding boxes scores where the top `config.two_stage_num_proposals` scoring bounding boxes are
+ picked as region proposals in the first stage. Output of bounding box binary classification (i.e.
+ foreground and background).
+ enc_outputs_coord_logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, 4)`, *optional*, returned when `config.with_box_refine=True` and `config.two_stage=True`):
+ Logits of predicted bounding boxes coordinates in the first stage.
+ """
+
+ loss: Optional[torch.FloatTensor] = None
+ loss_dict: Optional[Dict] = None
+ logits: torch.FloatTensor = None
+ pred_boxes: torch.FloatTensor = None
+ auxiliary_outputs: Optional[List[Dict]] = None
+ init_reference_points: Optional[torch.FloatTensor] = None
+ last_hidden_state: Optional[torch.FloatTensor] = None
+ intermediate_hidden_states: Optional[torch.FloatTensor] = None
+ intermediate_reference_points: Optional[torch.FloatTensor] = None
+ decoder_hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+ decoder_attentions: Optional[Tuple[torch.FloatTensor]] = None
+ cross_attentions: Optional[Tuple[torch.FloatTensor]] = None
+ encoder_last_hidden_state: Optional[torch.FloatTensor] = None
+ encoder_hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+ encoder_attentions: Optional[Tuple[torch.FloatTensor]] = None
+ enc_outputs_class: Optional = None
+ enc_outputs_coord_logits: Optional = None
+
+
+def _get_clones(module, N):
+ return nn.ModuleList([copy.deepcopy(module) for i in range(N)])
+
+
+def inverse_sigmoid(x, eps=1e-5):
+ x = x.clamp(min=0, max=1)
+ x1 = x.clamp(min=eps)
+ x2 = (1 - x).clamp(min=eps)
+ return torch.log(x1 / x2)
+
+
+# Copied from transformers.models.detr.modeling_detr.DetrFrozenBatchNorm2d with Detr->DeformableDetr
+class DeformableDetrFrozenBatchNorm2d(nn.Module):
+ """
+ BatchNorm2d where the batch statistics and the affine parameters are fixed.
+
+ Copy-paste from torchvision.misc.ops with added eps before rqsrt, without which any other models than
+ torchvision.models.resnet[18,34,50,101] produce nans.
+ """
+
+ def __init__(self, n):
+ super().__init__()
+ self.register_buffer("weight", torch.ones(n))
+ self.register_buffer("bias", torch.zeros(n))
+ self.register_buffer("running_mean", torch.zeros(n))
+ self.register_buffer("running_var", torch.ones(n))
+
+ def _load_from_state_dict(
+ self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs
+ ):
+ num_batches_tracked_key = prefix + "num_batches_tracked"
+ if num_batches_tracked_key in state_dict:
+ del state_dict[num_batches_tracked_key]
+
+ super()._load_from_state_dict(
+ state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs
+ )
+
+ def forward(self, x):
+ # move reshapes to the beginning
+ # to make it user-friendly
+ weight = self.weight.reshape(1, -1, 1, 1)
+ bias = self.bias.reshape(1, -1, 1, 1)
+ running_var = self.running_var.reshape(1, -1, 1, 1)
+ running_mean = self.running_mean.reshape(1, -1, 1, 1)
+ epsilon = 1e-5
+ scale = weight * (running_var + epsilon).rsqrt()
+ bias = bias - running_mean * scale
+ return x * scale + bias
+
+
+# Copied from transformers.models.detr.modeling_detr.replace_batch_norm with Detr->DeformableDetr
+def replace_batch_norm(model):
+ r"""
+ Recursively replace all `torch.nn.BatchNorm2d` with `DeformableDetrFrozenBatchNorm2d`.
+
+ Args:
+ model (torch.nn.Module):
+ input model
+ """
+ for name, module in model.named_children():
+ if isinstance(module, nn.BatchNorm2d):
+ new_module = DeformableDetrFrozenBatchNorm2d(module.num_features)
+
+ if not module.weight.device == torch.device("meta"):
+ new_module.weight.data.copy_(module.weight)
+ new_module.bias.data.copy_(module.bias)
+ new_module.running_mean.data.copy_(module.running_mean)
+ new_module.running_var.data.copy_(module.running_var)
+
+ model._modules[name] = new_module
+
+ if len(list(module.children())) > 0:
+ replace_batch_norm(module)
+
+
+class DeformableDetrConvEncoder(nn.Module):
+ """
+ Convolutional backbone, using either the AutoBackbone API or one from the timm library.
+
+ nn.BatchNorm2d layers are replaced by DeformableDetrFrozenBatchNorm2d as defined above.
+
+ """
+
+ def __init__(self, config):
+ super().__init__()
+
+ self.config = config
+
+ # For backwards compatibility we have to use the timm library directly instead of the AutoBackbone API
+ if config.use_timm_backbone:
+ # We default to values which were previously hard-coded. This enables configurability from the config
+ # using backbone arguments, while keeping the default behavior the same.
+ requires_backends(self, ["timm"])
+ kwargs = getattr(config, "backbone_kwargs", {})
+ kwargs = {} if kwargs is None else kwargs.copy()
+ out_indices = kwargs.pop("out_indices", (2, 3, 4) if config.num_feature_levels > 1 else (4,))
+ num_channels = kwargs.pop("in_chans", config.num_channels)
+ if config.dilation:
+ kwargs["output_stride"] = kwargs.get("output_stride", 16)
+ backbone = create_model(
+ config.backbone,
+ pretrained=config.use_pretrained_backbone,
+ features_only=True,
+ out_indices=out_indices,
+ in_chans=num_channels,
+ **kwargs,
+ )
+ else:
+ backbone = load_backbone(config)
+
+ # replace batch norm by frozen batch norm
+ with torch.no_grad():
+ replace_batch_norm(backbone)
+ self.model = backbone
+ self.intermediate_channel_sizes = (
+ self.model.feature_info.channels() if config.use_timm_backbone else self.model.channels
+ )
+
+ backbone_model_type = None
+ if config.backbone is not None:
+ backbone_model_type = config.backbone
+ elif config.backbone_config is not None:
+ backbone_model_type = config.backbone_config.model_type
+ else:
+ raise ValueError("Either `backbone` or `backbone_config` should be provided in the config")
+
+ if "resnet" in backbone_model_type:
+ for name, parameter in self.model.named_parameters():
+ if config.use_timm_backbone:
+ if "layer2" not in name and "layer3" not in name and "layer4" not in name:
+ parameter.requires_grad_(False)
+ else:
+ if "stage.1" not in name and "stage.2" not in name and "stage.3" not in name:
+ parameter.requires_grad_(False)
+
+ # Copied from transformers.models.detr.modeling_detr.DetrConvEncoder.forward with Detr->DeformableDetr
+ def forward(self, pixel_values: torch.Tensor, pixel_mask: torch.Tensor):
+ # send pixel_values through the model to get list of feature maps
+ features = self.model(pixel_values) if self.config.use_timm_backbone else self.model(pixel_values).feature_maps
+
+ out = []
+ for feature_map in features:
+ # downsample pixel_mask to match shape of corresponding feature_map
+ mask = nn.functional.interpolate(pixel_mask[None].float(), size=feature_map.shape[-2:]).to(torch.bool)[0]
+ out.append((feature_map, mask))
+ return out
+
+
+# Copied from transformers.models.detr.modeling_detr.DetrConvModel with Detr->DeformableDetr
+class DeformableDetrConvModel(nn.Module):
+ """
+ This module adds 2D position embeddings to all intermediate feature maps of the convolutional encoder.
+ """
+
+ def __init__(self, conv_encoder, position_embedding):
+ super().__init__()
+ self.conv_encoder = conv_encoder
+ self.position_embedding = position_embedding
+
+ def forward(self, pixel_values, pixel_mask):
+ # send pixel_values and pixel_mask through backbone to get list of (feature_map, pixel_mask) tuples
+ out = self.conv_encoder(pixel_values, pixel_mask)
+ pos = []
+ for feature_map, mask in out:
+ # position encoding
+ pos.append(self.position_embedding(feature_map, mask).to(feature_map.dtype))
+
+ return out, pos
+
+
+class DeformableDetrSinePositionEmbedding(nn.Module):
+ """
+ This is a more standard version of the position embedding, very similar to the one used by the Attention is all you
+ need paper, generalized to work on images.
+ """
+
+ def __init__(self, embedding_dim=64, temperature=10000, normalize=False, scale=None):
+ super().__init__()
+ self.embedding_dim = embedding_dim
+ self.temperature = temperature
+ self.normalize = normalize
+ if scale is not None and normalize is False:
+ raise ValueError("normalize should be True if scale is passed")
+ if scale is None:
+ scale = 2 * math.pi
+ self.scale = scale
+
+ def forward(self, pixel_values, pixel_mask):
+ if pixel_mask is None:
+ raise ValueError("No pixel mask provided")
+ y_embed = pixel_mask.cumsum(1, dtype=pixel_values.dtype)
+ x_embed = pixel_mask.cumsum(2, dtype=pixel_values.dtype)
+ if self.normalize:
+ eps = 1e-6
+ y_embed = (y_embed - 0.5) / (y_embed[:, -1:, :] + eps) * self.scale
+ x_embed = (x_embed - 0.5) / (x_embed[:, :, -1:] + eps) * self.scale
+
+ dim_t = torch.arange(self.embedding_dim, dtype=pixel_values.dtype, device=pixel_values.device)
+ dim_t = self.temperature ** (2 * torch.div(dim_t, 2, rounding_mode="floor") / self.embedding_dim)
+
+ pos_x = x_embed[:, :, :, None] / dim_t
+ pos_y = y_embed[:, :, :, None] / dim_t
+ pos_x = torch.stack((pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4).flatten(3)
+ pos_y = torch.stack((pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4).flatten(3)
+ pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
+ return pos
+
+
+# Copied from transformers.models.detr.modeling_detr.DetrLearnedPositionEmbedding
+class DeformableDetrLearnedPositionEmbedding(nn.Module):
+ """
+ This module learns positional embeddings up to a fixed maximum size.
+ """
+
+ def __init__(self, embedding_dim=256):
+ super().__init__()
+ self.row_embeddings = nn.Embedding(50, embedding_dim)
+ self.column_embeddings = nn.Embedding(50, embedding_dim)
+
+ def forward(self, pixel_values, pixel_mask=None):
+ height, width = pixel_values.shape[-2:]
+ width_values = torch.arange(width, device=pixel_values.device)
+ height_values = torch.arange(height, device=pixel_values.device)
+ x_emb = self.column_embeddings(width_values)
+ y_emb = self.row_embeddings(height_values)
+ pos = torch.cat([x_emb.unsqueeze(0).repeat(height, 1, 1), y_emb.unsqueeze(1).repeat(1, width, 1)], dim=-1)
+ pos = pos.permute(2, 0, 1)
+ pos = pos.unsqueeze(0)
+ pos = pos.repeat(pixel_values.shape[0], 1, 1, 1)
+ return pos
+
+
+# Copied from transformers.models.detr.modeling_detr.build_position_encoding with Detr->DeformableDetr
+def build_position_encoding(config):
+ n_steps = config.d_model // 2
+ if config.position_embedding_type == "sine":
+ # TODO find a better way of exposing other arguments
+ position_embedding = DeformableDetrSinePositionEmbedding(n_steps, normalize=True)
+ elif config.position_embedding_type == "learned":
+ position_embedding = DeformableDetrLearnedPositionEmbedding(n_steps)
+ else:
+ raise ValueError(f"Not supported {config.position_embedding_type}")
+
+ return position_embedding
+
+
+class DeformableDetrMultiscaleDeformableAttention(nn.Module):
+ """
+ Multiscale deformable attention as proposed in Deformable DETR.
+ """
+
+ def __init__(self, config: DeformableDetrConfig, num_heads: int, n_points: int):
+ super().__init__()
+
+ self.attn = MultiScaleDeformableAttention()
+
+ if config.d_model % num_heads != 0:
+ raise ValueError(
+ f"embed_dim (d_model) must be divisible by num_heads, but got {config.d_model} and {num_heads}"
+ )
+ dim_per_head = config.d_model // num_heads
+ # check if dim_per_head is power of 2
+ if not ((dim_per_head & (dim_per_head - 1) == 0) and dim_per_head != 0):
+ warnings.warn(
+ "You'd better set embed_dim (d_model) in DeformableDetrMultiscaleDeformableAttention to make the"
+ " dimension of each attention head a power of 2 which is more efficient in the authors' CUDA"
+ " implementation."
+ )
+
+ self.im2col_step = 64
+
+ self.d_model = config.d_model
+ self.n_levels = config.num_feature_levels
+ self.n_heads = num_heads
+ self.n_points = n_points
+
+ self.sampling_offsets = nn.Linear(config.d_model, num_heads * self.n_levels * n_points * 2)
+ self.attention_weights = nn.Linear(config.d_model, num_heads * self.n_levels * n_points)
+ self.value_proj = nn.Linear(config.d_model, config.d_model)
+ self.output_proj = nn.Linear(config.d_model, config.d_model)
+
+ self.disable_custom_kernels = config.disable_custom_kernels
+
+ def with_pos_embed(self, tensor: torch.Tensor, position_embeddings: Optional[Tensor]):
+ return tensor if position_embeddings is None else tensor + position_embeddings
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: Optional[torch.Tensor] = None,
+ encoder_hidden_states=None,
+ encoder_attention_mask=None,
+ position_embeddings: Optional[torch.Tensor] = None,
+ reference_points=None,
+ spatial_shapes=None,
+ spatial_shapes_list=None,
+ level_start_index=None,
+ output_attentions: bool = False,
+ ):
+ # add position embeddings to the hidden states before projecting to queries and keys
+ if position_embeddings is not None:
+ hidden_states = self.with_pos_embed(hidden_states, position_embeddings)
+
+ batch_size, num_queries, _ = hidden_states.shape
+ batch_size, sequence_length, _ = encoder_hidden_states.shape
+ total_elements = sum(height * width for height, width in spatial_shapes_list)
+ if total_elements != sequence_length:
+ raise ValueError(
+ "Make sure to align the spatial shapes with the sequence length of the encoder hidden states"
+ )
+
+ value = self.value_proj(encoder_hidden_states)
+ if attention_mask is not None:
+ # we invert the attention_mask
+ value = value.masked_fill(~attention_mask[..., None], float(0))
+ value = value.view(batch_size, sequence_length, self.n_heads, self.d_model // self.n_heads)
+ sampling_offsets = self.sampling_offsets(hidden_states).view(
+ batch_size, num_queries, self.n_heads, self.n_levels, self.n_points, 2
+ )
+ attention_weights = self.attention_weights(hidden_states).view(
+ batch_size, num_queries, self.n_heads, self.n_levels * self.n_points
+ )
+ attention_weights = F.softmax(attention_weights, -1).view(
+ batch_size, num_queries, self.n_heads, self.n_levels, self.n_points
+ )
+ # batch_size, num_queries, n_heads, n_levels, n_points, 2
+ num_coordinates = reference_points.shape[-1]
+ if num_coordinates == 2:
+ offset_normalizer = torch.stack([spatial_shapes[..., 1], spatial_shapes[..., 0]], -1)
+ sampling_locations = (
+ reference_points[:, :, None, :, None, :]
+ + sampling_offsets / offset_normalizer[None, None, None, :, None, :]
+ )
+ elif num_coordinates == 4:
+ sampling_locations = (
+ reference_points[:, :, None, :, None, :2]
+ + sampling_offsets / self.n_points * reference_points[:, :, None, :, None, 2:] * 0.5
+ )
+ else:
+ raise ValueError(f"Last dim of reference_points must be 2 or 4, but got {reference_points.shape[-1]}")
+
+ output = self.attn(
+ value,
+ spatial_shapes,
+ spatial_shapes_list,
+ level_start_index,
+ sampling_locations,
+ attention_weights,
+ self.im2col_step,
+ )
+
+ output = self.output_proj(output)
+
+ return output, attention_weights
+
+
+class DeformableDetrMultiheadAttention(nn.Module):
+ """
+ Multi-headed attention from 'Attention Is All You Need' paper.
+
+ Here, we add position embeddings to the queries and keys (as explained in the Deformable DETR paper).
+ """
+
+ def __init__(
+ self,
+ embed_dim: int,
+ num_heads: int,
+ dropout: float = 0.0,
+ bias: bool = True,
+ ):
+ super().__init__()
+ self.embed_dim = embed_dim
+ self.num_heads = num_heads
+ self.dropout = dropout
+ self.head_dim = embed_dim // num_heads
+ if self.head_dim * num_heads != self.embed_dim:
+ raise ValueError(
+ f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`:"
+ f" {num_heads})."
+ )
+ self.scaling = self.head_dim**-0.5
+
+ self.k_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.v_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.q_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+
+ def _shape(self, tensor: torch.Tensor, seq_len: int, batch_size: int):
+ return tensor.view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous()
+
+ def with_pos_embed(self, tensor: torch.Tensor, position_embeddings: Optional[Tensor]):
+ return tensor if position_embeddings is None else tensor + position_embeddings
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: Optional[torch.Tensor] = None,
+ position_embeddings: Optional[torch.Tensor] = None,
+ output_attentions: bool = False,
+ ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
+ """Input shape: Batch x Time x Channel"""
+
+ batch_size, target_len, embed_dim = hidden_states.size()
+ # add position embeddings to the hidden states before projecting to queries and keys
+ if position_embeddings is not None:
+ hidden_states_original = hidden_states
+ hidden_states = self.with_pos_embed(hidden_states, position_embeddings)
+
+ # get queries, keys and values
+ query_states = self.q_proj(hidden_states) * self.scaling
+ key_states = self._shape(self.k_proj(hidden_states), -1, batch_size)
+ value_states = self._shape(self.v_proj(hidden_states_original), -1, batch_size)
+
+ proj_shape = (batch_size * self.num_heads, -1, self.head_dim)
+ query_states = self._shape(query_states, target_len, batch_size).view(*proj_shape)
+ key_states = key_states.view(*proj_shape)
+ value_states = value_states.view(*proj_shape)
+
+ source_len = key_states.size(1)
+
+ attn_weights = torch.bmm(query_states, key_states.transpose(1, 2))
+
+ if attn_weights.size() != (batch_size * self.num_heads, target_len, source_len):
+ raise ValueError(
+ f"Attention weights should be of size {(batch_size * self.num_heads, target_len, source_len)}, but is"
+ f" {attn_weights.size()}"
+ )
+
+ # expand attention_mask
+ if attention_mask is not None:
+ # [batch_size, seq_len] -> [batch_size, 1, target_seq_len, source_seq_len]
+ attention_mask = _prepare_4d_attention_mask(attention_mask, hidden_states.dtype)
+
+ if attention_mask is not None:
+ if attention_mask.size() != (batch_size, 1, target_len, source_len):
+ raise ValueError(
+ f"Attention mask should be of size {(batch_size, 1, target_len, source_len)}, but is"
+ f" {attention_mask.size()}"
+ )
+ attn_weights = attn_weights.view(batch_size, self.num_heads, target_len, source_len) + attention_mask
+ attn_weights = attn_weights.view(batch_size * self.num_heads, target_len, source_len)
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1)
+
+ if output_attentions:
+ # this operation is a bit awkward, but it's required to
+ # make sure that attn_weights keeps its gradient.
+ # In order to do so, attn_weights have to reshaped
+ # twice and have to be reused in the following
+ attn_weights_reshaped = attn_weights.view(batch_size, self.num_heads, target_len, source_len)
+ attn_weights = attn_weights_reshaped.view(batch_size * self.num_heads, target_len, source_len)
+ else:
+ attn_weights_reshaped = None
+
+ attn_probs = nn.functional.dropout(attn_weights, p=self.dropout, training=self.training)
+
+ attn_output = torch.bmm(attn_probs, value_states)
+
+ if attn_output.size() != (
+ batch_size * self.num_heads,
+ target_len,
+ self.head_dim,
+ ):
+ raise ValueError(
+ f"`attn_output` should be of size {(batch_size, self.num_heads, target_len, self.head_dim)}, but is"
+ f" {attn_output.size()}"
+ )
+
+ attn_output = attn_output.view(batch_size, self.num_heads, target_len, self.head_dim)
+ attn_output = attn_output.transpose(1, 2)
+ attn_output = attn_output.reshape(batch_size, target_len, embed_dim)
+
+ attn_output = self.out_proj(attn_output)
+
+ return attn_output, attn_weights_reshaped
+
+
+class DeformableDetrEncoderLayer(nn.Module):
+ def __init__(self, config: DeformableDetrConfig):
+ super().__init__()
+ self.embed_dim = config.d_model
+ self.self_attn = DeformableDetrMultiscaleDeformableAttention(
+ config,
+ num_heads=config.encoder_attention_heads,
+ n_points=config.encoder_n_points,
+ )
+ self.self_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+ self.dropout = config.dropout
+ self.activation_fn = ACT2FN[config.activation_function]
+ self.activation_dropout = config.activation_dropout
+ self.fc1 = nn.Linear(self.embed_dim, config.encoder_ffn_dim)
+ self.fc2 = nn.Linear(config.encoder_ffn_dim, self.embed_dim)
+ self.final_layer_norm = nn.LayerNorm(self.embed_dim)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor,
+ position_embeddings: torch.Tensor = None,
+ reference_points=None,
+ spatial_shapes=None,
+ spatial_shapes_list=None,
+ level_start_index=None,
+ output_attentions: bool = False,
+ ):
+ """
+ Args:
+ hidden_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+ Input to the layer.
+ attention_mask (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
+ Attention mask.
+ position_embeddings (`torch.FloatTensor`, *optional*):
+ Position embeddings, to be added to `hidden_states`.
+ reference_points (`torch.FloatTensor`, *optional*):
+ Reference points.
+ spatial_shapes (`torch.LongTensor`, *optional*):
+ Spatial shapes of the backbone feature maps.
+ level_start_index (`torch.LongTensor`, *optional*):
+ Level start index.
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+ returned tensors for more detail.
+ """
+ residual = hidden_states
+
+ # Apply Multi-scale Deformable Attention Module on the multi-scale feature maps.
+ hidden_states, attn_weights = self.self_attn(
+ hidden_states=hidden_states,
+ attention_mask=attention_mask,
+ encoder_hidden_states=hidden_states,
+ encoder_attention_mask=attention_mask,
+ position_embeddings=position_embeddings,
+ reference_points=reference_points,
+ spatial_shapes=spatial_shapes,
+ spatial_shapes_list=spatial_shapes_list,
+ level_start_index=level_start_index,
+ output_attentions=output_attentions,
+ )
+
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+ hidden_states = self.self_attn_layer_norm(hidden_states)
+
+ residual = hidden_states
+ hidden_states = self.activation_fn(self.fc1(hidden_states))
+ hidden_states = nn.functional.dropout(hidden_states, p=self.activation_dropout, training=self.training)
+
+ hidden_states = self.fc2(hidden_states)
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+
+ hidden_states = residual + hidden_states
+ hidden_states = self.final_layer_norm(hidden_states)
+
+ if self.training:
+ if torch.isinf(hidden_states).any() or torch.isnan(hidden_states).any():
+ clamp_value = torch.finfo(hidden_states.dtype).max - 1000
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ outputs = (hidden_states,)
+
+ if output_attentions:
+ outputs += (attn_weights,)
+
+ return outputs
+
+
+class DeformableDetrDecoderLayer(nn.Module):
+ def __init__(self, config: DeformableDetrConfig):
+ super().__init__()
+ self.embed_dim = config.d_model
+
+ # self-attention
+ self.self_attn = DeformableDetrMultiheadAttention(
+ embed_dim=self.embed_dim,
+ num_heads=config.decoder_attention_heads,
+ dropout=config.attention_dropout,
+ )
+ self.dropout = config.dropout
+ self.activation_fn = ACT2FN[config.activation_function]
+ self.activation_dropout = config.activation_dropout
+
+ self.self_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+ # cross-attention
+ self.encoder_attn = DeformableDetrMultiscaleDeformableAttention(
+ config,
+ num_heads=config.decoder_attention_heads,
+ n_points=config.decoder_n_points,
+ )
+ self.encoder_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+ # feedforward neural networks
+ self.fc1 = nn.Linear(self.embed_dim, config.decoder_ffn_dim)
+ self.fc2 = nn.Linear(config.decoder_ffn_dim, self.embed_dim)
+ self.final_layer_norm = nn.LayerNorm(self.embed_dim)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: Optional[torch.Tensor] = None,
+ reference_points=None,
+ spatial_shapes=None,
+ spatial_shapes_list=None,
+ level_start_index=None,
+ encoder_hidden_states: Optional[torch.Tensor] = None,
+ encoder_attention_mask: Optional[torch.Tensor] = None,
+ output_attentions: Optional[bool] = False,
+ ):
+ """
+ Args:
+ hidden_states (`torch.FloatTensor`):
+ Input to the layer of shape `(seq_len, batch, embed_dim)`.
+ position_embeddings (`torch.FloatTensor`, *optional*):
+ Position embeddings that are added to the queries and keys in the self-attention layer.
+ reference_points (`torch.FloatTensor`, *optional*):
+ Reference points.
+ spatial_shapes (`torch.LongTensor`, *optional*):
+ Spatial shapes.
+ level_start_index (`torch.LongTensor`, *optional*):
+ Level start index.
+ encoder_hidden_states (`torch.FloatTensor`):
+ cross attention input to the layer of shape `(seq_len, batch, embed_dim)`
+ encoder_attention_mask (`torch.FloatTensor`): encoder attention mask of size
+ `(batch, 1, target_len, source_len)` where padding elements are indicated by very large negative
+ values.
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+ returned tensors for more detail.
+ """
+ residual = hidden_states
+
+ # Self Attention
+ hidden_states, self_attn_weights = self.self_attn(
+ hidden_states=hidden_states,
+ position_embeddings=position_embeddings,
+ output_attentions=output_attentions,
+ )
+
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+ hidden_states = self.self_attn_layer_norm(hidden_states)
+
+ second_residual = hidden_states
+
+ # Cross-Attention
+ cross_attn_weights = None
+ hidden_states, cross_attn_weights = self.encoder_attn(
+ hidden_states=hidden_states,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ encoder_attention_mask=encoder_attention_mask,
+ position_embeddings=position_embeddings,
+ reference_points=reference_points,
+ spatial_shapes=spatial_shapes,
+ spatial_shapes_list=spatial_shapes_list,
+ level_start_index=level_start_index,
+ output_attentions=output_attentions,
+ )
+
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = second_residual + hidden_states
+
+ hidden_states = self.encoder_attn_layer_norm(hidden_states)
+
+ # Fully Connected
+ residual = hidden_states
+ hidden_states = self.activation_fn(self.fc1(hidden_states))
+ hidden_states = nn.functional.dropout(hidden_states, p=self.activation_dropout, training=self.training)
+ hidden_states = self.fc2(hidden_states)
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+ hidden_states = self.final_layer_norm(hidden_states)
+
+ outputs = (hidden_states,)
+
+ if output_attentions:
+ outputs += (self_attn_weights, cross_attn_weights)
+
+ return outputs
+
+
+class DeformableDetrPreTrainedModel(PreTrainedModel):
+ config_class = DeformableDetrConfig
+ base_model_prefix = "model"
+ main_input_name = "pixel_values"
+ supports_gradient_checkpointing = True
+ _no_split_modules = [
+ r"DeformableDetrConvEncoder",
+ r"DeformableDetrEncoderLayer",
+ r"DeformableDetrDecoderLayer",
+ ]
+
+ def _init_weights(self, module):
+ std = self.config.init_std
+
+ if isinstance(module, DeformableDetrLearnedPositionEmbedding):
+ nn.init.uniform_(module.row_embeddings.weight)
+ nn.init.uniform_(module.column_embeddings.weight)
+ elif isinstance(module, DeformableDetrMultiscaleDeformableAttention):
+ nn.init.constant_(module.sampling_offsets.weight.data, 0.0)
+ default_dtype = torch.get_default_dtype()
+ thetas = torch.arange(module.n_heads, dtype=torch.int64).to(default_dtype) * (
+ 2.0 * math.pi / module.n_heads
+ )
+ grid_init = torch.stack([thetas.cos(), thetas.sin()], -1)
+ grid_init = (
+ (grid_init / grid_init.abs().max(-1, keepdim=True)[0])
+ .view(module.n_heads, 1, 1, 2)
+ .repeat(1, module.n_levels, module.n_points, 1)
+ )
+ for i in range(module.n_points):
+ grid_init[:, :, i, :] *= i + 1
+ with torch.no_grad():
+ module.sampling_offsets.bias = nn.Parameter(grid_init.view(-1))
+ nn.init.constant_(module.attention_weights.weight.data, 0.0)
+ nn.init.constant_(module.attention_weights.bias.data, 0.0)
+ nn.init.xavier_uniform_(module.value_proj.weight.data)
+ nn.init.constant_(module.value_proj.bias.data, 0.0)
+ nn.init.xavier_uniform_(module.output_proj.weight.data)
+ nn.init.constant_(module.output_proj.bias.data, 0.0)
+ elif isinstance(module, (nn.Linear, nn.Conv2d, nn.BatchNorm2d)):
+ # Slightly different from the TF version which uses truncated_normal for initialization
+ # cf https://github.com/pytorch/pytorch/pull/5617
+ module.weight.data.normal_(mean=0.0, std=std)
+ if module.bias is not None:
+ module.bias.data.zero_()
+ elif isinstance(module, nn.Embedding):
+ module.weight.data.normal_(mean=0.0, std=std)
+ if module.padding_idx is not None:
+ module.weight.data[module.padding_idx].zero_()
+ if hasattr(module, "reference_points") and not self.config.two_stage:
+ nn.init.xavier_uniform_(module.reference_points.weight.data, gain=1.0)
+ nn.init.constant_(module.reference_points.bias.data, 0.0)
+ if hasattr(module, "level_embed"):
+ nn.init.normal_(module.level_embed)
+
+
+DEFORMABLE_DETR_START_DOCSTRING = r"""
+ This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
+ library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
+ etc.)
+
+ This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
+ Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
+ and behavior.
+
+ Parameters:
+ config ([`DeformableDetrConfig`]):
+ Model configuration class with all the parameters of the model. Initializing with a config file does not
+ load the weights associated with the model, only the configuration. Check out the
+ [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+"""
+
+DEFORMABLE_DETR_INPUTS_DOCSTRING = r"""
+ Args:
+ pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
+ Pixel values. Padding will be ignored by default should you provide it.
+
+ Pixel values can be obtained using [`AutoImageProcessor`]. See [`DeformableDetrImageProcessor.__call__`]
+ for details.
+
+ pixel_mask (`torch.LongTensor` of shape `(batch_size, height, width)`, *optional*):
+ Mask to avoid performing attention on padding pixel values. Mask values selected in `[0, 1]`:
+
+ - 1 for pixels that are real (i.e. **not masked**),
+ - 0 for pixels that are padding (i.e. **masked**).
+
+ [What are attention masks?](../glossary#attention-mask)
+
+ decoder_attention_mask (`torch.FloatTensor` of shape `(batch_size, num_queries)`, *optional*):
+ Not used by default. Can be used to mask object queries.
+ encoder_outputs (`tuple(tuple(torch.FloatTensor)`, *optional*):
+ Tuple consists of (`last_hidden_state`, *optional*: `hidden_states`, *optional*: `attentions`)
+ `last_hidden_state` of shape `(batch_size, sequence_length, hidden_size)`, *optional*) is a sequence of
+ hidden-states at the output of the last layer of the encoder. Used in the cross-attention of the decoder.
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+ Optionally, instead of passing the flattened feature map (output of the backbone + projection layer), you
+ can choose to directly pass a flattened representation of an image.
+ decoder_inputs_embeds (`torch.FloatTensor` of shape `(batch_size, num_queries, hidden_size)`, *optional*):
+ Optionally, instead of initializing the queries with a tensor of zeros, you can choose to directly pass an
+ embedded representation.
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
+ tensors for more detail.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+ more detail.
+ return_dict (`bool`, *optional*):
+ Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.
+"""
+
+
+class DeformableDetrEncoder(DeformableDetrPreTrainedModel):
+ """
+ Transformer encoder consisting of *config.encoder_layers* deformable attention layers. Each layer is a
+ [`DeformableDetrEncoderLayer`].
+
+ The encoder updates the flattened multi-scale feature maps through multiple deformable attention layers.
+
+ Args:
+ config: DeformableDetrConfig
+ """
+
+ def __init__(self, config: DeformableDetrConfig):
+ super().__init__(config)
+ self.gradient_checkpointing = False
+
+ self.dropout = config.dropout
+ self.layers = nn.ModuleList([DeformableDetrEncoderLayer(config) for _ in range(config.encoder_layers)])
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @staticmethod
+ def get_reference_points(spatial_shapes, valid_ratios, device):
+ """
+ Get reference points for each feature map. Used in decoder.
+
+ Args:
+ spatial_shapes (`torch.LongTensor` of shape `(num_feature_levels, 2)`):
+ Spatial shapes of each feature map.
+ valid_ratios (`torch.FloatTensor` of shape `(batch_size, num_feature_levels, 2)`):
+ Valid ratios of each feature map.
+ device (`torch.device`):
+ Device on which to create the tensors.
+ Returns:
+ `torch.FloatTensor` of shape `(batch_size, num_queries, num_feature_levels, 2)`
+ """
+ reference_points_list = []
+ for level, (height, width) in enumerate(spatial_shapes):
+ ref_y, ref_x = meshgrid(
+ torch.linspace(0.5, height - 0.5, height, dtype=valid_ratios.dtype, device=device),
+ torch.linspace(0.5, width - 0.5, width, dtype=valid_ratios.dtype, device=device),
+ indexing="ij",
+ )
+ # TODO: valid_ratios could be useless here. check https://github.com/fundamentalvision/Deformable-DETR/issues/36
+ ref_y = ref_y.reshape(-1)[None] / (valid_ratios[:, None, level, 1] * height)
+ ref_x = ref_x.reshape(-1)[None] / (valid_ratios[:, None, level, 0] * width)
+ ref = torch.stack((ref_x, ref_y), -1)
+ reference_points_list.append(ref)
+ reference_points = torch.cat(reference_points_list, 1)
+ reference_points = reference_points[:, :, None] * valid_ratios[:, None]
+ return reference_points
+
+ def forward(
+ self,
+ inputs_embeds=None,
+ attention_mask=None,
+ position_embeddings=None,
+ spatial_shapes=None,
+ spatial_shapes_list=None,
+ level_start_index=None,
+ valid_ratios=None,
+ output_attentions=None,
+ output_hidden_states=None,
+ return_dict=None,
+ ):
+ r"""
+ Args:
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+ Flattened feature map (output of the backbone + projection layer) that is passed to the encoder.
+ attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing attention on padding pixel features. Mask values selected in `[0, 1]`:
+ - 1 for pixel features that are real (i.e. **not masked**),
+ - 0 for pixel features that are padding (i.e. **masked**).
+ [What are attention masks?](../glossary#attention-mask)
+ position_embeddings (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+ Position embeddings that are added to the queries and keys in each self-attention layer.
+ spatial_shapes (`torch.LongTensor` of shape `(num_feature_levels, 2)`):
+ Spatial shapes of each feature map.
+ level_start_index (`torch.LongTensor` of shape `(num_feature_levels)`):
+ Starting index of each feature map.
+ valid_ratios (`torch.FloatTensor` of shape `(batch_size, num_feature_levels, 2)`):
+ Ratio of valid area in each feature level.
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+ returned tensors for more detail.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
+ for more detail.
+ return_dict (`bool`, *optional*):
+ Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.
+ """
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+ hidden_states = inputs_embeds
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+
+ spatial_shapes_tuple = tuple(spatial_shapes_list)
+ reference_points = self.get_reference_points(spatial_shapes_tuple, valid_ratios, device=inputs_embeds.device)
+
+ encoder_states = () if output_hidden_states else None
+ all_attentions = () if output_attentions else None
+ for i, encoder_layer in enumerate(self.layers):
+ if output_hidden_states:
+ encoder_states = encoder_states + (hidden_states,)
+ if self.gradient_checkpointing and self.training:
+ layer_outputs = self._gradient_checkpointing_func(
+ encoder_layer.__call__,
+ hidden_states,
+ attention_mask,
+ position_embeddings,
+ reference_points,
+ spatial_shapes,
+ spatial_shapes_list,
+ level_start_index,
+ output_attentions,
+ )
+ else:
+ layer_outputs = encoder_layer(
+ hidden_states,
+ attention_mask,
+ position_embeddings=position_embeddings,
+ reference_points=reference_points,
+ spatial_shapes=spatial_shapes,
+ spatial_shapes_list=spatial_shapes_list,
+ level_start_index=level_start_index,
+ output_attentions=output_attentions,
+ )
+
+ hidden_states = layer_outputs[0]
+
+ if output_attentions:
+ all_attentions = all_attentions + (layer_outputs[1],)
+
+ if output_hidden_states:
+ encoder_states = encoder_states + (hidden_states,)
+
+ if not return_dict:
+ return tuple(v for v in [hidden_states, encoder_states, all_attentions] if v is not None)
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ hidden_states=encoder_states,
+ attentions=all_attentions,
+ )
+
+
+class DeformableDetrDecoder(DeformableDetrPreTrainedModel):
+ """
+ Transformer decoder consisting of *config.decoder_layers* layers. Each layer is a [`DeformableDetrDecoderLayer`].
+
+ The decoder updates the query embeddings through multiple self-attention and cross-attention layers.
+
+ Some tweaks for Deformable DETR:
+
+ - `position_embeddings`, `reference_points`, `spatial_shapes` and `valid_ratios` are added to the forward pass.
+ - it also returns a stack of intermediate outputs and reference points from all decoding layers.
+
+ Args:
+ config: DeformableDetrConfig
+ """
+
+ def __init__(self, config: DeformableDetrConfig):
+ super().__init__(config)
+
+ self.dropout = config.dropout
+ self.layers = nn.ModuleList([DeformableDetrDecoderLayer(config) for _ in range(config.decoder_layers)])
+ self.gradient_checkpointing = False
+
+ # hack implementation for iterative bounding box refinement and two-stage Deformable DETR
+ self.bbox_embed = None
+ self.class_embed = None
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def forward(
+ self,
+ inputs_embeds=None,
+ encoder_hidden_states=None,
+ encoder_attention_mask=None,
+ position_embeddings=None,
+ reference_points=None,
+ spatial_shapes=None,
+ spatial_shapes_list=None,
+ level_start_index=None,
+ valid_ratios=None,
+ output_attentions=None,
+ output_hidden_states=None,
+ return_dict=None,
+ ):
+ r"""
+ Args:
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, num_queries, hidden_size)`):
+ The query embeddings that are passed into the decoder.
+ encoder_hidden_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+ Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention
+ of the decoder.
+ encoder_attention_mask (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing cross-attention on padding pixel_values of the encoder. Mask values selected
+ in `[0, 1]`:
+ - 1 for pixels that are real (i.e. **not masked**),
+ - 0 for pixels that are padding (i.e. **masked**).
+ position_embeddings (`torch.FloatTensor` of shape `(batch_size, num_queries, hidden_size)`, *optional*):
+ Position embeddings that are added to the queries and keys in each self-attention layer.
+ reference_points (`torch.FloatTensor` of shape `(batch_size, num_queries, 4)` is `as_two_stage` else `(batch_size, num_queries, 2)` or , *optional*):
+ Reference point in range `[0, 1]`, top-left (0,0), bottom-right (1, 1), including padding area.
+ spatial_shapes (`torch.FloatTensor` of shape `(num_feature_levels, 2)`):
+ Spatial shapes of the feature maps.
+ level_start_index (`torch.LongTensor` of shape `(num_feature_levels)`, *optional*):
+ Indexes for the start of each feature level. In range `[0, sequence_length]`.
+ valid_ratios (`torch.FloatTensor` of shape `(batch_size, num_feature_levels, 2)`, *optional*):
+ Ratio of valid area in each feature level.
+
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+ returned tensors for more detail.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
+ for more detail.
+ return_dict (`bool`, *optional*):
+ Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.
+ """
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+ if inputs_embeds is not None:
+ hidden_states = inputs_embeds
+
+ # decoder layers
+ all_hidden_states = () if output_hidden_states else None
+ all_self_attns = () if output_attentions else None
+ all_cross_attentions = () if (output_attentions and encoder_hidden_states is not None) else None
+ intermediate = ()
+ intermediate_reference_points = ()
+
+ for idx, decoder_layer in enumerate(self.layers):
+ num_coordinates = reference_points.shape[-1]
+ if num_coordinates == 4:
+ reference_points_input = (
+ reference_points[:, :, None] * torch.cat([valid_ratios, valid_ratios], -1)[:, None]
+ )
+ elif reference_points.shape[-1] == 2:
+ reference_points_input = reference_points[:, :, None] * valid_ratios[:, None]
+ else:
+ raise ValueError("Reference points' last dimension must be of size 2")
+
+ if output_hidden_states:
+ all_hidden_states += (hidden_states,)
+
+ if self.gradient_checkpointing and self.training:
+ layer_outputs = self._gradient_checkpointing_func(
+ decoder_layer.__call__,
+ hidden_states,
+ position_embeddings,
+ reference_points_input,
+ spatial_shapes,
+ spatial_shapes_list,
+ level_start_index,
+ encoder_hidden_states,
+ encoder_attention_mask,
+ output_attentions,
+ )
+ else:
+ layer_outputs = decoder_layer(
+ hidden_states,
+ position_embeddings=position_embeddings,
+ encoder_hidden_states=encoder_hidden_states,
+ reference_points=reference_points_input,
+ spatial_shapes=spatial_shapes,
+ spatial_shapes_list=spatial_shapes_list,
+ level_start_index=level_start_index,
+ encoder_attention_mask=encoder_attention_mask,
+ output_attentions=output_attentions,
+ )
+
+ hidden_states = layer_outputs[0]
+
+ # hack implementation for iterative bounding box refinement
+ if self.bbox_embed is not None:
+ tmp = self.bbox_embed[idx](hidden_states)
+ num_coordinates = reference_points.shape[-1]
+ if num_coordinates == 4:
+ new_reference_points = tmp + inverse_sigmoid(reference_points)
+ new_reference_points = new_reference_points.sigmoid()
+ elif num_coordinates == 2:
+ new_reference_points = tmp
+ new_reference_points[..., :2] = tmp[..., :2] + inverse_sigmoid(reference_points)
+ new_reference_points = new_reference_points.sigmoid()
+ else:
+ raise ValueError(
+ f"Last dim of reference_points must be 2 or 4, but got {reference_points.shape[-1]}"
+ )
+ reference_points = new_reference_points.detach()
+
+ intermediate += (hidden_states,)
+ intermediate_reference_points += (reference_points,)
+
+ if output_attentions:
+ all_self_attns += (layer_outputs[1],)
+
+ if encoder_hidden_states is not None:
+ all_cross_attentions += (layer_outputs[2],)
+
+ # Keep batch_size as first dimension
+ intermediate = torch.stack(intermediate, dim=1)
+ intermediate_reference_points = torch.stack(intermediate_reference_points, dim=1)
+
+ # add hidden states from the last decoder layer
+ if output_hidden_states:
+ all_hidden_states += (hidden_states,)
+
+ if not return_dict:
+ return tuple(
+ v
+ for v in [
+ hidden_states,
+ intermediate,
+ intermediate_reference_points,
+ all_hidden_states,
+ all_self_attns,
+ all_cross_attentions,
+ ]
+ if v is not None
+ )
+ return DeformableDetrDecoderOutput(
+ last_hidden_state=hidden_states,
+ intermediate_hidden_states=intermediate,
+ intermediate_reference_points=intermediate_reference_points,
+ hidden_states=all_hidden_states,
+ attentions=all_self_attns,
+ cross_attentions=all_cross_attentions,
+ )
+
+
+@add_start_docstrings(
+ """
+ The bare Deformable DETR Model (consisting of a backbone and encoder-decoder Transformer) outputting raw
+ hidden-states without any specific head on top.
+ """,
+ DEFORMABLE_DETR_START_DOCSTRING,
+)
+class DeformableDetrModel(DeformableDetrPreTrainedModel):
+ def __init__(self, config: DeformableDetrConfig):
+ super().__init__(config)
+
+ # Create backbone + positional encoding
+ backbone = DeformableDetrConvEncoder(config)
+ position_embeddings = build_position_encoding(config)
+ self.backbone = DeformableDetrConvModel(backbone, position_embeddings)
+
+ # Create input projection layers
+ if config.num_feature_levels > 1:
+ num_backbone_outs = len(backbone.intermediate_channel_sizes)
+ input_proj_list = []
+ for _ in range(num_backbone_outs):
+ in_channels = backbone.intermediate_channel_sizes[_]
+ input_proj_list.append(
+ nn.Sequential(
+ nn.Conv2d(in_channels, config.d_model, kernel_size=1),
+ nn.GroupNorm(32, config.d_model),
+ )
+ )
+ for _ in range(config.num_feature_levels - num_backbone_outs):
+ input_proj_list.append(
+ nn.Sequential(
+ nn.Conv2d(
+ in_channels,
+ config.d_model,
+ kernel_size=3,
+ stride=2,
+ padding=1,
+ ),
+ nn.GroupNorm(32, config.d_model),
+ )
+ )
+ in_channels = config.d_model
+ self.input_proj = nn.ModuleList(input_proj_list)
+ else:
+ self.input_proj = nn.ModuleList(
+ [
+ nn.Sequential(
+ nn.Conv2d(
+ backbone.intermediate_channel_sizes[-1],
+ config.d_model,
+ kernel_size=1,
+ ),
+ nn.GroupNorm(32, config.d_model),
+ )
+ ]
+ )
+
+ if not config.two_stage:
+ self.query_position_embeddings = nn.Embedding(config.num_queries, config.d_model * 2)
+
+ self.encoder = DeformableDetrEncoder(config)
+ self.decoder = DeformableDetrDecoder(config)
+
+ self.level_embed = nn.Parameter(torch.Tensor(config.num_feature_levels, config.d_model))
+
+ if config.two_stage:
+ self.enc_output = nn.Linear(config.d_model, config.d_model)
+ self.enc_output_norm = nn.LayerNorm(config.d_model)
+ self.pos_trans = nn.Linear(config.d_model * 2, config.d_model * 2)
+ self.pos_trans_norm = nn.LayerNorm(config.d_model * 2)
+ else:
+ self.reference_points = nn.Linear(config.d_model, 2)
+
+ self.post_init()
+
+ def get_encoder(self):
+ return self.encoder
+
+ def get_decoder(self):
+ return self.decoder
+
+ def freeze_backbone(self):
+ for name, param in self.backbone.conv_encoder.model.named_parameters():
+ param.requires_grad_(False)
+
+ def unfreeze_backbone(self):
+ for name, param in self.backbone.conv_encoder.model.named_parameters():
+ param.requires_grad_(True)
+
+ def get_valid_ratio(self, mask, dtype=torch.float32):
+ """Get the valid ratio of all feature maps."""
+
+ _, height, width = mask.shape
+ valid_height = torch.sum(mask[:, :, 0], 1)
+ valid_width = torch.sum(mask[:, 0, :], 1)
+ valid_ratio_height = valid_height.to(dtype) / height
+ valid_ratio_width = valid_width.to(dtype) / width
+ valid_ratio = torch.stack([valid_ratio_width, valid_ratio_height], -1)
+ return valid_ratio
+
+ def get_proposal_pos_embed(self, proposals):
+ """Get the position embedding of the proposals."""
+
+ num_pos_feats = self.config.d_model // 2
+ temperature = 10000
+ scale = 2 * math.pi
+
+ dim_t = torch.arange(num_pos_feats, dtype=proposals.dtype, device=proposals.device)
+ dim_t = temperature ** (2 * torch.div(dim_t, 2, rounding_mode="floor") / num_pos_feats)
+ # batch_size, num_queries, 4
+ proposals = proposals.sigmoid() * scale
+ # batch_size, num_queries, 4, 128
+ pos = proposals[:, :, :, None] / dim_t
+ # batch_size, num_queries, 4, 64, 2 -> batch_size, num_queries, 512
+ pos = torch.stack((pos[:, :, :, 0::2].sin(), pos[:, :, :, 1::2].cos()), dim=4).flatten(2)
+ return pos
+
+ def gen_encoder_output_proposals(self, enc_output, padding_mask, spatial_shapes):
+ """Generate the encoder output proposals from encoded enc_output.
+
+ Args:
+ enc_output (Tensor[batch_size, sequence_length, hidden_size]): Output of the encoder.
+ padding_mask (Tensor[batch_size, sequence_length]): Padding mask for `enc_output`.
+ spatial_shapes (List[Tuple[int, int]]): Spatial shapes of the feature maps.
+
+ Returns:
+ `tuple(torch.FloatTensor)`: A tuple of feature map and bbox prediction.
+ - object_query (Tensor[batch_size, sequence_length, hidden_size]): Object query features. Later used to
+ directly predict a bounding box. (without the need of a decoder)
+ - output_proposals (Tensor[batch_size, sequence_length, 4]): Normalized proposals, after an inverse
+ sigmoid.
+ """
+ batch_size = enc_output.shape[0]
+ proposals = []
+ _cur = 0
+ for level, (height, width) in enumerate(spatial_shapes):
+ mask_flatten_ = padding_mask[:, _cur : (_cur + height * width)].view(batch_size, height, width, 1)
+ valid_height = torch.sum(~mask_flatten_[:, :, 0, 0], 1)
+ valid_width = torch.sum(~mask_flatten_[:, 0, :, 0], 1)
+
+ grid_y, grid_x = meshgrid(
+ torch.linspace(
+ 0,
+ height - 1,
+ height,
+ dtype=enc_output.dtype,
+ device=enc_output.device,
+ ),
+ torch.linspace(
+ 0,
+ width - 1,
+ width,
+ dtype=enc_output.dtype,
+ device=enc_output.device,
+ ),
+ indexing="ij",
+ )
+ grid = torch.cat([grid_x.unsqueeze(-1), grid_y.unsqueeze(-1)], -1)
+
+ scale = torch.cat([valid_width.unsqueeze(-1), valid_height.unsqueeze(-1)], 1).view(batch_size, 1, 1, 2)
+ grid = (grid.unsqueeze(0).expand(batch_size, -1, -1, -1) + 0.5) / scale
+ width_heigth = torch.ones_like(grid) * 0.05 * (2.0**level)
+ proposal = torch.cat((grid, width_heigth), -1).view(batch_size, -1, 4)
+ proposals.append(proposal)
+ _cur += height * width
+ output_proposals = torch.cat(proposals, 1)
+ output_proposals_valid = ((output_proposals > 0.01) & (output_proposals < 0.99)).all(-1, keepdim=True)
+ output_proposals = torch.log(output_proposals / (1 - output_proposals)) # inverse sigmoid
+ output_proposals = output_proposals.masked_fill(padding_mask.unsqueeze(-1), float("inf"))
+ output_proposals = output_proposals.masked_fill(~output_proposals_valid, float("inf"))
+
+ # assign each pixel as an object query
+ object_query = enc_output
+ object_query = object_query.masked_fill(padding_mask.unsqueeze(-1), float(0))
+ object_query = object_query.masked_fill(~output_proposals_valid, float(0))
+ object_query = self.enc_output_norm(self.enc_output(object_query))
+ return object_query, output_proposals
+
+ @add_start_docstrings_to_model_forward(DEFORMABLE_DETR_INPUTS_DOCSTRING)
+ @replace_return_docstrings(output_type=DeformableDetrModelOutput, config_class=_CONFIG_FOR_DOC)
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ pixel_mask: Optional[torch.LongTensor] = None,
+ decoder_attention_mask: Optional[torch.FloatTensor] = None,
+ encoder_outputs: Optional[torch.FloatTensor] = None,
+ inputs_embeds: Optional[torch.FloatTensor] = None,
+ decoder_inputs_embeds: Optional[torch.FloatTensor] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ ) -> Union[Tuple[torch.FloatTensor], DeformableDetrModelOutput]:
+ r"""
+ Returns:
+
+ Examples:
+
+ ```python
+ >>> from transformers import AutoImageProcessor, DeformableDetrModel
+ >>> from PIL import Image
+ >>> import requests
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> image = Image.open(requests.get(url, stream=True).raw)
+
+ >>> image_processor = AutoImageProcessor.from_pretrained("SenseTime/deformable-detr")
+ >>> model = DeformableDetrModel.from_pretrained("SenseTime/deformable-detr")
+
+ >>> inputs = image_processor(images=image, return_tensors="pt")
+
+ >>> outputs = model(**inputs)
+
+ >>> last_hidden_states = outputs.last_hidden_state
+ >>> list(last_hidden_states.shape)
+ [1, 300, 256]
+ ```"""
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+ batch_size, num_channels, height, width = pixel_values.shape
+ device = pixel_values.device
+
+ if pixel_mask is None:
+ pixel_mask = torch.ones(((batch_size, height, width)), dtype=torch.long, device=device)
+
+ # Extract multi-scale feature maps of same resolution `config.d_model` (cf Figure 4 in paper)
+ # First, sent pixel_values + pixel_mask through Backbone to obtain the features
+ # which is a list of tuples
+ features, position_embeddings_list = self.backbone(pixel_values, pixel_mask)
+
+ # Then, apply 1x1 convolution to reduce the channel dimension to d_model (256 by default)
+ sources = []
+ masks = []
+ for level, (source, mask) in enumerate(features):
+ sources.append(self.input_proj[level](source))
+ masks.append(mask)
+ if mask is None:
+ raise ValueError("No attention mask was provided")
+
+ # Lowest resolution feature maps are obtained via 3x3 stride 2 convolutions on the final stage
+ if self.config.num_feature_levels > len(sources):
+ _len_sources = len(sources)
+ for level in range(_len_sources, self.config.num_feature_levels):
+ if level == _len_sources:
+ source = self.input_proj[level](features[-1][0])
+ else:
+ source = self.input_proj[level](sources[-1])
+ mask = nn.functional.interpolate(pixel_mask[None].to(pixel_values.dtype), size=source.shape[-2:]).to(
+ torch.bool
+ )[0]
+ pos_l = self.backbone.position_embedding(source, mask).to(source.dtype)
+ sources.append(source)
+ masks.append(mask)
+ position_embeddings_list.append(pos_l)
+
+ # Create queries
+ query_embeds = None
+ if not self.config.two_stage:
+ query_embeds = self.query_position_embeddings.weight
+
+ # Prepare encoder inputs (by flattening)
+ source_flatten = []
+ mask_flatten = []
+ lvl_pos_embed_flatten = []
+ spatial_shapes_list = []
+ for level, (source, mask, pos_embed) in enumerate(zip(sources, masks, position_embeddings_list)):
+ batch_size, num_channels, height, width = source.shape
+ spatial_shape = (height, width)
+ spatial_shapes_list.append(spatial_shape)
+ source = source.flatten(2).transpose(1, 2)
+ mask = mask.flatten(1)
+ pos_embed = pos_embed.flatten(2).transpose(1, 2)
+ lvl_pos_embed = pos_embed + self.level_embed[level].view(1, 1, -1)
+ lvl_pos_embed_flatten.append(lvl_pos_embed)
+ source_flatten.append(source)
+ mask_flatten.append(mask)
+ source_flatten = torch.cat(source_flatten, 1)
+ mask_flatten = torch.cat(mask_flatten, 1)
+ lvl_pos_embed_flatten = torch.cat(lvl_pos_embed_flatten, 1)
+ spatial_shapes = torch.as_tensor(spatial_shapes_list, dtype=torch.long, device=source_flatten.device)
+ level_start_index = torch.cat((spatial_shapes.new_zeros((1,)), spatial_shapes.prod(1).cumsum(0)[:-1]))
+ valid_ratios = torch.stack([self.get_valid_ratio(m, dtype=source_flatten.dtype) for m in masks], 1)
+
+ # Fourth, sent source_flatten + mask_flatten + lvl_pos_embed_flatten (backbone + proj layer output) through encoder
+ # Also provide spatial_shapes, level_start_index and valid_ratios
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ inputs_embeds=source_flatten,
+ attention_mask=mask_flatten,
+ position_embeddings=lvl_pos_embed_flatten,
+ spatial_shapes=spatial_shapes,
+ spatial_shapes_list=spatial_shapes_list,
+ level_start_index=level_start_index,
+ valid_ratios=valid_ratios,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ # If the user passed a tuple for encoder_outputs, we wrap it in a BaseModelOutput when return_dict=True
+ elif return_dict and not isinstance(encoder_outputs, BaseModelOutput):
+ encoder_outputs = BaseModelOutput(
+ last_hidden_state=encoder_outputs[0],
+ hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
+ attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
+ )
+
+ # Fifth, prepare decoder inputs
+ batch_size, _, num_channels = encoder_outputs[0].shape
+ enc_outputs_class = None
+ enc_outputs_coord_logits = None
+ if self.config.two_stage:
+ object_query_embedding, output_proposals = self.gen_encoder_output_proposals(
+ encoder_outputs[0], ~mask_flatten, spatial_shapes_list
+ )
+
+ # hack implementation for two-stage Deformable DETR
+ # apply a detection head to each pixel (A.4 in paper)
+ # linear projection for bounding box binary classification (i.e. foreground and background)
+ enc_outputs_class = self.decoder.class_embed[-1](object_query_embedding)
+ # 3-layer FFN to predict bounding boxes coordinates (bbox regression branch)
+ delta_bbox = self.decoder.bbox_embed[-1](object_query_embedding)
+ enc_outputs_coord_logits = delta_bbox + output_proposals
+
+ # only keep top scoring `config.two_stage_num_proposals` proposals
+ topk = self.config.two_stage_num_proposals
+ topk_proposals = torch.topk(enc_outputs_class[..., 0], topk, dim=1)[1]
+ topk_coords_logits = torch.gather(
+ enc_outputs_coord_logits,
+ 1,
+ topk_proposals.unsqueeze(-1).repeat(1, 1, 4),
+ )
+
+ topk_coords_logits = topk_coords_logits.detach()
+ reference_points = topk_coords_logits.sigmoid()
+ init_reference_points = reference_points
+ pos_trans_out = self.pos_trans_norm(self.pos_trans(self.get_proposal_pos_embed(topk_coords_logits)))
+ query_embed, target = torch.split(pos_trans_out, num_channels, dim=2)
+ else:
+ query_embed, target = torch.split(query_embeds, num_channels, dim=1)
+ query_embed = query_embed.unsqueeze(0).expand(batch_size, -1, -1)
+ target = target.unsqueeze(0).expand(batch_size, -1, -1)
+ reference_points = self.reference_points(query_embed).sigmoid()
+ init_reference_points = reference_points
+
+ decoder_outputs = self.decoder(
+ inputs_embeds=target,
+ position_embeddings=query_embed,
+ encoder_hidden_states=encoder_outputs[0],
+ encoder_attention_mask=mask_flatten,
+ reference_points=reference_points,
+ spatial_shapes=spatial_shapes,
+ spatial_shapes_list=spatial_shapes_list,
+ level_start_index=level_start_index,
+ valid_ratios=valid_ratios,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ if not return_dict:
+ enc_outputs = tuple(value for value in [enc_outputs_class, enc_outputs_coord_logits] if value is not None)
+ tuple_outputs = (init_reference_points,) + decoder_outputs + encoder_outputs + enc_outputs
+
+ return tuple_outputs
+
+ return DeformableDetrModelOutput(
+ init_reference_points=init_reference_points,
+ last_hidden_state=decoder_outputs.last_hidden_state,
+ intermediate_hidden_states=decoder_outputs.intermediate_hidden_states,
+ intermediate_reference_points=decoder_outputs.intermediate_reference_points,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ enc_outputs_class=enc_outputs_class,
+ enc_outputs_coord_logits=enc_outputs_coord_logits,
+ )
+
+
+# Copied from transformers.models.detr.modeling_detr.DetrMLPPredictionHead
+class DeformableDetrMLPPredictionHead(nn.Module):
+ """
+ Very simple multi-layer perceptron (MLP, also called FFN), used to predict the normalized center coordinates,
+ height and width of a bounding box w.r.t. an image.
+
+ Copied from https://github.com/facebookresearch/detr/blob/master/models/detr.py
+
+ """
+
+ def __init__(self, input_dim, hidden_dim, output_dim, num_layers):
+ super().__init__()
+ self.num_layers = num_layers
+ h = [hidden_dim] * (num_layers - 1)
+ self.layers = nn.ModuleList(nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim]))
+
+ def forward(self, x):
+ for i, layer in enumerate(self.layers):
+ x = nn.functional.relu(layer(x)) if i < self.num_layers - 1 else layer(x)
+ return x
+
+
+@add_start_docstrings(
+ """
+ Deformable DETR Model (consisting of a backbone and encoder-decoder Transformer) with object detection heads on
+ top, for tasks such as COCO detection.
+ """,
+ DEFORMABLE_DETR_START_DOCSTRING,
+)
+class DeformableDetrForObjectDetection(DeformableDetrPreTrainedModel):
+ # When using clones, all layers > 0 will be clones, but layer 0 *is* required
+ _tied_weights_keys = [r"bbox_embed\.[1-9]\d*", r"class_embed\.[1-9]\d*"]
+ # We can't initialize the model on meta device as some weights are modified during the initialization
+ _no_split_modules = None
+
+ def __init__(self, config: DeformableDetrConfig):
+ super().__init__(config)
+
+ # Deformable DETR encoder-decoder model
+ self.model = DeformableDetrModel(config)
+ # Detection heads on top
+ self.class_embed = nn.Linear(config.d_model, config.num_labels)
+ self.bbox_embed = DeformableDetrMLPPredictionHead(
+ input_dim=config.d_model,
+ hidden_dim=config.d_model,
+ output_dim=4,
+ num_layers=3,
+ )
+
+ prior_prob = 0.01
+ bias_value = -math.log((1 - prior_prob) / prior_prob)
+ self.class_embed.bias.data = torch.ones(config.num_labels) * bias_value
+ nn.init.constant_(self.bbox_embed.layers[-1].weight.data, 0)
+ nn.init.constant_(self.bbox_embed.layers[-1].bias.data, 0)
+
+ # if two-stage, the last class_embed and bbox_embed is for region proposal generation
+ num_pred = (config.decoder_layers + 1) if config.two_stage else config.decoder_layers
+ if config.with_box_refine:
+ self.class_embed = _get_clones(self.class_embed, num_pred)
+ self.bbox_embed = _get_clones(self.bbox_embed, num_pred)
+ nn.init.constant_(self.bbox_embed[0].layers[-1].bias.data[2:], -2.0)
+ # hack implementation for iterative bounding box refinement
+ self.model.decoder.bbox_embed = self.bbox_embed
+ else:
+ nn.init.constant_(self.bbox_embed.layers[-1].bias.data[2:], -2.0)
+ self.class_embed = nn.ModuleList([self.class_embed for _ in range(num_pred)])
+ self.bbox_embed = nn.ModuleList([self.bbox_embed for _ in range(num_pred)])
+ self.model.decoder.bbox_embed = None
+ if config.two_stage:
+ # hack implementation for two-stage
+ self.model.decoder.class_embed = self.class_embed
+ for box_embed in self.bbox_embed:
+ nn.init.constant_(box_embed.layers[-1].bias.data[2:], 0.0)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @add_start_docstrings_to_model_forward(DEFORMABLE_DETR_INPUTS_DOCSTRING)
+ @replace_return_docstrings(output_type=DeformableDetrObjectDetectionOutput, config_class=_CONFIG_FOR_DOC)
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ pixel_mask: Optional[torch.LongTensor] = None,
+ decoder_attention_mask: Optional[torch.FloatTensor] = None,
+ encoder_outputs: Optional[torch.FloatTensor] = None,
+ inputs_embeds: Optional[torch.FloatTensor] = None,
+ decoder_inputs_embeds: Optional[torch.FloatTensor] = None,
+ labels: Optional[List[dict]] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ ) -> Union[Tuple[torch.FloatTensor], DeformableDetrObjectDetectionOutput]:
+ r"""
+ labels (`List[Dict]` of len `(batch_size,)`, *optional*):
+ Labels for computing the bipartite matching loss. List of dicts, each dictionary containing at least the
+ following 2 keys: 'class_labels' and 'boxes' (the class labels and bounding boxes of an image in the batch
+ respectively). The class labels themselves should be a `torch.LongTensor` of len `(number of bounding boxes
+ in the image,)` and the boxes a `torch.FloatTensor` of shape `(number of bounding boxes in the image, 4)`.
+
+ Returns:
+
+ Examples:
+
+ ```python
+ >>> from transformers import AutoImageProcessor, DeformableDetrForObjectDetection
+ >>> from PIL import Image
+ >>> import requests
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> image = Image.open(requests.get(url, stream=True).raw)
+
+ >>> image_processor = AutoImageProcessor.from_pretrained("SenseTime/deformable-detr")
+ >>> model = DeformableDetrForObjectDetection.from_pretrained("SenseTime/deformable-detr")
+
+ >>> inputs = image_processor(images=image, return_tensors="pt")
+ >>> outputs = model(**inputs)
+
+ >>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
+ >>> target_sizes = torch.tensor([image.size[::-1]])
+ >>> results = image_processor.post_process_object_detection(outputs, threshold=0.5, target_sizes=target_sizes)[
+ ... 0
+ ... ]
+ >>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
+ ... box = [round(i, 2) for i in box.tolist()]
+ ... print(
+ ... f"Detected {model.config.id2label[label.item()]} with confidence "
+ ... f"{round(score.item(), 3)} at location {box}"
+ ... )
+ Detected cat with confidence 0.8 at location [16.5, 52.84, 318.25, 470.78]
+ Detected cat with confidence 0.789 at location [342.19, 24.3, 640.02, 372.25]
+ Detected remote with confidence 0.633 at location [40.79, 72.78, 176.76, 117.25]
+ ```"""
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+ # First, sent images through DETR base model to obtain encoder + decoder outputs
+ outputs = self.model(
+ pixel_values,
+ pixel_mask=pixel_mask,
+ decoder_attention_mask=decoder_attention_mask,
+ encoder_outputs=encoder_outputs,
+ inputs_embeds=inputs_embeds,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ hidden_states = outputs.intermediate_hidden_states if return_dict else outputs[2]
+ init_reference = outputs.init_reference_points if return_dict else outputs[0]
+ inter_references = outputs.intermediate_reference_points if return_dict else outputs[3]
+
+ # class logits + predicted bounding boxes
+ outputs_classes = []
+ outputs_coords = []
+
+ for level in range(hidden_states.shape[1]):
+ if level == 0:
+ reference = init_reference
+ else:
+ reference = inter_references[:, level - 1]
+ reference = inverse_sigmoid(reference)
+ outputs_class = self.class_embed[level](hidden_states[:, level])
+ delta_bbox = self.bbox_embed[level](hidden_states[:, level])
+ if reference.shape[-1] == 4:
+ outputs_coord_logits = delta_bbox + reference
+ elif reference.shape[-1] == 2:
+ delta_bbox[..., :2] += reference
+ outputs_coord_logits = delta_bbox
+ else:
+ raise ValueError(f"reference.shape[-1] should be 4 or 2, but got {reference.shape[-1]}")
+ outputs_coord = outputs_coord_logits.sigmoid()
+ outputs_classes.append(outputs_class)
+ outputs_coords.append(outputs_coord)
+ outputs_class = torch.stack(outputs_classes)
+ outputs_coord = torch.stack(outputs_coords)
+
+ logits = outputs_class[-1]
+ pred_boxes = outputs_coord[-1]
+
+ loss, loss_dict, auxiliary_outputs = None, None, None
+ if labels is not None:
+ loss, loss_dict, auxiliary_outputs = self.loss_function(
+ logits,
+ labels,
+ self.device,
+ pred_boxes,
+ self.config,
+ outputs_class,
+ outputs_coord,
+ )
+ if not return_dict:
+ if auxiliary_outputs is not None:
+ output = (logits, pred_boxes) + auxiliary_outputs + outputs
+ else:
+ output = (logits, pred_boxes) + outputs
+ tuple_outputs = ((loss, loss_dict) + output) if loss is not None else output
+
+ return tuple_outputs
+
+ dict_outputs = DeformableDetrObjectDetectionOutput(
+ loss=loss,
+ loss_dict=loss_dict,
+ logits=logits,
+ pred_boxes=pred_boxes,
+ auxiliary_outputs=auxiliary_outputs,
+ last_hidden_state=outputs.last_hidden_state,
+ decoder_hidden_states=outputs.decoder_hidden_states,
+ decoder_attentions=outputs.decoder_attentions,
+ cross_attentions=outputs.cross_attentions,
+ encoder_last_hidden_state=outputs.encoder_last_hidden_state,
+ encoder_hidden_states=outputs.encoder_hidden_states,
+ encoder_attentions=outputs.encoder_attentions,
+ intermediate_hidden_states=outputs.intermediate_hidden_states,
+ intermediate_reference_points=outputs.intermediate_reference_points,
+ init_reference_points=outputs.init_reference_points,
+ enc_outputs_class=outputs.enc_outputs_class,
+ enc_outputs_coord_logits=outputs.enc_outputs_coord_logits,
+ )
+
+ return dict_outputs
+
+
+__all__ = [
+ "DeformableDetrForObjectDetection",
+ "DeformableDetrModel",
+ "DeformableDetrPreTrainedModel",
+]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/modular_deformable_detr.py b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/modular_deformable_detr.py
new file mode 100644
index 0000000000000000000000000000000000000000..5dfb6048c3431b151ae1cf47157abf7e917c536c
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/deformable_detr/modular_deformable_detr.py
@@ -0,0 +1,144 @@
+from typing import List, Tuple, Union
+
+from transformers.models.detr.image_processing_detr_fast import DetrImageProcessorFast
+
+from ...image_transforms import center_to_corners_format
+from ...utils import (
+ TensorType,
+ is_torch_available,
+ logging,
+)
+
+
+if is_torch_available():
+ import torch
+
+
+logger = logging.get_logger(__name__)
+
+
+class DeformableDetrImageProcessorFast(DetrImageProcessorFast):
+ def post_process(self, outputs, target_sizes):
+ """
+ Converts the raw output of [`DeformableDetrForObjectDetection`] into final bounding boxes in (top_left_x,
+ top_left_y, bottom_right_x, bottom_right_y) format. Only supports PyTorch.
+
+ Args:
+ outputs ([`DeformableDetrObjectDetectionOutput`]):
+ Raw outputs of the model.
+ target_sizes (`torch.Tensor` of shape `(batch_size, 2)`):
+ Tensor containing the size (height, width) of each image of the batch. For evaluation, this must be the
+ original image size (before any data augmentation). For visualization, this should be the image size
+ after data augment, but before padding.
+ Returns:
+ `List[Dict]`: A list of dictionaries, each dictionary containing the scores, labels and boxes for an image
+ in the batch as predicted by the model.
+ """
+ logger.warning_once(
+ "`post_process` is deprecated and will be removed in v5 of Transformers, please use"
+ " `post_process_object_detection` instead, with `threshold=0.` for equivalent results.",
+ )
+
+ out_logits, out_bbox = outputs.logits, outputs.pred_boxes
+
+ if len(out_logits) != len(target_sizes):
+ raise ValueError("Make sure that you pass in as many target sizes as the batch dimension of the logits")
+ if target_sizes.shape[1] != 2:
+ raise ValueError("Each element of target_sizes must contain the size (h, w) of each image of the batch")
+
+ prob = out_logits.sigmoid()
+ topk_values, topk_indexes = torch.topk(prob.view(out_logits.shape[0], -1), 100, dim=1)
+ scores = topk_values
+ topk_boxes = torch.div(topk_indexes, out_logits.shape[2], rounding_mode="floor")
+ labels = topk_indexes % out_logits.shape[2]
+ boxes = center_to_corners_format(out_bbox)
+ boxes = torch.gather(boxes, 1, topk_boxes.unsqueeze(-1).repeat(1, 1, 4))
+
+ # and from relative [0, 1] to absolute [0, height] coordinates
+ img_h, img_w = target_sizes.unbind(1)
+ scale_fct = torch.stack([img_w, img_h, img_w, img_h], dim=1)
+ boxes = boxes * scale_fct[:, None, :]
+
+ results = [{"scores": s, "labels": l, "boxes": b} for s, l, b in zip(scores, labels, boxes)]
+
+ return results
+
+ def post_process_object_detection(
+ self, outputs, threshold: float = 0.5, target_sizes: Union[TensorType, List[Tuple]] = None, top_k: int = 100
+ ):
+ """
+ Converts the raw output of [`DeformableDetrForObjectDetection`] into final bounding boxes in (top_left_x,
+ top_left_y, bottom_right_x, bottom_right_y) format. Only supports PyTorch.
+
+ Args:
+ outputs ([`DetrObjectDetectionOutput`]):
+ Raw outputs of the model.
+ threshold (`float`, *optional*):
+ Score threshold to keep object detection predictions.
+ target_sizes (`torch.Tensor` or `List[Tuple[int, int]]`, *optional*):
+ Tensor of shape `(batch_size, 2)` or list of tuples (`Tuple[int, int]`) containing the target size
+ (height, width) of each image in the batch. If left to None, predictions will not be resized.
+ top_k (`int`, *optional*, defaults to 100):
+ Keep only top k bounding boxes before filtering by thresholding.
+
+ Returns:
+ `List[Dict]`: A list of dictionaries, each dictionary containing the scores, labels and boxes for an image
+ in the batch as predicted by the model.
+ """
+ out_logits, out_bbox = outputs.logits, outputs.pred_boxes
+
+ if target_sizes is not None:
+ if len(out_logits) != len(target_sizes):
+ raise ValueError(
+ "Make sure that you pass in as many target sizes as the batch dimension of the logits"
+ )
+
+ prob = out_logits.sigmoid()
+ prob = prob.view(out_logits.shape[0], -1)
+ k_value = min(top_k, prob.size(1))
+ topk_values, topk_indexes = torch.topk(prob, k_value, dim=1)
+ scores = topk_values
+ topk_boxes = torch.div(topk_indexes, out_logits.shape[2], rounding_mode="floor")
+ labels = topk_indexes % out_logits.shape[2]
+ boxes = center_to_corners_format(out_bbox)
+ boxes = torch.gather(boxes, 1, topk_boxes.unsqueeze(-1).repeat(1, 1, 4))
+
+ # and from relative [0, 1] to absolute [0, height] coordinates
+ if target_sizes is not None:
+ if isinstance(target_sizes, List):
+ img_h = torch.Tensor([i[0] for i in target_sizes])
+ img_w = torch.Tensor([i[1] for i in target_sizes])
+ else:
+ img_h, img_w = target_sizes.unbind(1)
+ scale_fct = torch.stack([img_w, img_h, img_w, img_h], dim=1).to(boxes.device)
+ boxes = boxes * scale_fct[:, None, :]
+
+ results = []
+ for s, l, b in zip(scores, labels, boxes):
+ score = s[s > threshold]
+ label = l[s > threshold]
+ box = b[s > threshold]
+ results.append({"scores": score, "labels": label, "boxes": box})
+
+ return results
+
+ def post_process_segmentation():
+ raise NotImplementedError("Segmentation post-processing is not implemented for Deformable DETR yet.")
+
+ def post_process_instance():
+ raise NotImplementedError("Instance post-processing is not implemented for Deformable DETR yet.")
+
+ def post_process_panoptic():
+ raise NotImplementedError("Panoptic post-processing is not implemented for Deformable DETR yet.")
+
+ def post_process_instance_segmentation():
+ raise NotImplementedError("Segmentation post-processing is not implemented for Deformable DETR yet.")
+
+ def post_process_semantic_segmentation():
+ raise NotImplementedError("Semantic segmentation post-processing is not implemented for Deformable DETR yet.")
+
+ def post_process_panoptic_segmentation():
+ raise NotImplementedError("Panoptic segmentation post-processing is not implemented for Deformable DETR yet.")
+
+
+__all__ = ["DeformableDetrImageProcessorFast"]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__init__.py b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c29b5fc245ef93341fe476e148f4957da3ff145a
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__init__.py
@@ -0,0 +1,29 @@
+# Copyright 2024 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import TYPE_CHECKING
+
+from ...utils import _LazyModule
+from ...utils.import_utils import define_import_structure
+
+
+if TYPE_CHECKING:
+ from .configuration_mobilenet_v2 import *
+ from .feature_extraction_mobilenet_v2 import *
+ from .image_processing_mobilenet_v2 import *
+ from .modeling_mobilenet_v2 import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c5a4ede62362c2451d06ebce6da5fbae9ceeda75
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__pycache__/__init__.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__pycache__/configuration_mobilenet_v2.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__pycache__/configuration_mobilenet_v2.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a891792b96cfbfd7ee432131005324bb482b3c62
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__pycache__/configuration_mobilenet_v2.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__pycache__/feature_extraction_mobilenet_v2.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__pycache__/feature_extraction_mobilenet_v2.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d737289550b3b19f2d04e92947d743e8d2d06ba1
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__pycache__/feature_extraction_mobilenet_v2.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__pycache__/image_processing_mobilenet_v2.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__pycache__/image_processing_mobilenet_v2.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3b8221a3acef2eb56a79d95eb4394d138db99ce1
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__pycache__/image_processing_mobilenet_v2.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__pycache__/modeling_mobilenet_v2.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__pycache__/modeling_mobilenet_v2.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..98257f03e6853d86ae625703031dc4c34372911a
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/__pycache__/modeling_mobilenet_v2.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/configuration_mobilenet_v2.py b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/configuration_mobilenet_v2.py
new file mode 100644
index 0000000000000000000000000000000000000000..6cf64847e2cd644ebbde26bc972b9344705941e6
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/configuration_mobilenet_v2.py
@@ -0,0 +1,154 @@
+# coding=utf-8
+# Copyright 2022 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""MobileNetV2 model configuration"""
+
+from collections import OrderedDict
+from typing import Mapping
+
+from packaging import version
+
+from ...configuration_utils import PretrainedConfig
+from ...onnx import OnnxConfig
+from ...utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+
+class MobileNetV2Config(PretrainedConfig):
+ r"""
+ This is the configuration class to store the configuration of a [`MobileNetV2Model`]. It is used to instantiate a
+ MobileNetV2 model according to the specified arguments, defining the model architecture. Instantiating a
+ configuration with the defaults will yield a similar configuration to that of the MobileNetV2
+ [google/mobilenet_v2_1.0_224](https://huggingface.co/google/mobilenet_v2_1.0_224) architecture.
+
+ Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+ documentation from [`PretrainedConfig`] for more information.
+
+ Args:
+ num_channels (`int`, *optional*, defaults to 3):
+ The number of input channels.
+ image_size (`int`, *optional*, defaults to 224):
+ The size (resolution) of each image.
+ depth_multiplier (`float`, *optional*, defaults to 1.0):
+ Shrinks or expands the number of channels in each layer. Default is 1.0, which starts the network with 32
+ channels. This is sometimes also called "alpha" or "width multiplier".
+ depth_divisible_by (`int`, *optional*, defaults to 8):
+ The number of channels in each layer will always be a multiple of this number.
+ min_depth (`int`, *optional*, defaults to 8):
+ All layers will have at least this many channels.
+ expand_ratio (`float`, *optional*, defaults to 6.0):
+ The number of output channels of the first layer in each block is input channels times expansion ratio.
+ output_stride (`int`, *optional*, defaults to 32):
+ The ratio between the spatial resolution of the input and output feature maps. By default the model reduces
+ the input dimensions by a factor of 32. If `output_stride` is 8 or 16, the model uses dilated convolutions
+ on the depthwise layers instead of regular convolutions, so that the feature maps never become more than 8x
+ or 16x smaller than the input image.
+ first_layer_is_expansion (`bool`, *optional*, defaults to `True`):
+ True if the very first convolution layer is also the expansion layer for the first expansion block.
+ finegrained_output (`bool`, *optional*, defaults to `True`):
+ If true, the number of output channels in the final convolution layer will stay large (1280) even if
+ `depth_multiplier` is less than 1.
+ hidden_act (`str` or `function`, *optional*, defaults to `"relu6"`):
+ The non-linear activation function (function or string) in the Transformer encoder and convolution layers.
+ tf_padding (`bool`, *optional*, defaults to `True`):
+ Whether to use TensorFlow padding rules on the convolution layers.
+ classifier_dropout_prob (`float`, *optional*, defaults to 0.8):
+ The dropout ratio for attached classifiers.
+ initializer_range (`float`, *optional*, defaults to 0.02):
+ The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+ layer_norm_eps (`float`, *optional*, defaults to 0.001):
+ The epsilon used by the layer normalization layers.
+ semantic_loss_ignore_index (`int`, *optional*, defaults to 255):
+ The index that is ignored by the loss function of the semantic segmentation model.
+
+ Example:
+
+ ```python
+ >>> from transformers import MobileNetV2Config, MobileNetV2Model
+
+ >>> # Initializing a "mobilenet_v2_1.0_224" style configuration
+ >>> configuration = MobileNetV2Config()
+
+ >>> # Initializing a model from the "mobilenet_v2_1.0_224" style configuration
+ >>> model = MobileNetV2Model(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "mobilenet_v2"
+
+ def __init__(
+ self,
+ num_channels=3,
+ image_size=224,
+ depth_multiplier=1.0,
+ depth_divisible_by=8,
+ min_depth=8,
+ expand_ratio=6.0,
+ output_stride=32,
+ first_layer_is_expansion=True,
+ finegrained_output=True,
+ hidden_act="relu6",
+ tf_padding=True,
+ classifier_dropout_prob=0.8,
+ initializer_range=0.02,
+ layer_norm_eps=0.001,
+ semantic_loss_ignore_index=255,
+ **kwargs,
+ ):
+ super().__init__(**kwargs)
+
+ if depth_multiplier <= 0:
+ raise ValueError("depth_multiplier must be greater than zero.")
+
+ self.num_channels = num_channels
+ self.image_size = image_size
+ self.depth_multiplier = depth_multiplier
+ self.depth_divisible_by = depth_divisible_by
+ self.min_depth = min_depth
+ self.expand_ratio = expand_ratio
+ self.output_stride = output_stride
+ self.first_layer_is_expansion = first_layer_is_expansion
+ self.finegrained_output = finegrained_output
+ self.hidden_act = hidden_act
+ self.tf_padding = tf_padding
+ self.classifier_dropout_prob = classifier_dropout_prob
+ self.initializer_range = initializer_range
+ self.layer_norm_eps = layer_norm_eps
+ self.semantic_loss_ignore_index = semantic_loss_ignore_index
+
+
+class MobileNetV2OnnxConfig(OnnxConfig):
+ torch_onnx_minimum_version = version.parse("1.11")
+
+ @property
+ def inputs(self) -> Mapping[str, Mapping[int, str]]:
+ return OrderedDict([("pixel_values", {0: "batch"})])
+
+ @property
+ def outputs(self) -> Mapping[str, Mapping[int, str]]:
+ if self.task == "image-classification":
+ return OrderedDict([("logits", {0: "batch"})])
+ else:
+ return OrderedDict([("last_hidden_state", {0: "batch"}), ("pooler_output", {0: "batch"})])
+
+ @property
+ def atol_for_validation(self) -> float:
+ return 1e-4
+
+
+__all__ = ["MobileNetV2Config", "MobileNetV2OnnxConfig"]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/feature_extraction_mobilenet_v2.py b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/feature_extraction_mobilenet_v2.py
new file mode 100644
index 0000000000000000000000000000000000000000..09043aa4834e8c97a83e06f92ab5b4f018ceecb6
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/feature_extraction_mobilenet_v2.py
@@ -0,0 +1,36 @@
+# coding=utf-8
+# Copyright 2022 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Feature extractor class for MobileNetV2."""
+
+import warnings
+
+from ...utils import logging
+from .image_processing_mobilenet_v2 import MobileNetV2ImageProcessor
+
+
+logger = logging.get_logger(__name__)
+
+
+class MobileNetV2FeatureExtractor(MobileNetV2ImageProcessor):
+ def __init__(self, *args, **kwargs) -> None:
+ warnings.warn(
+ "The class MobileNetV2FeatureExtractor is deprecated and will be removed in version 5 of Transformers."
+ " Please use MobileNetV2ImageProcessor instead.",
+ FutureWarning,
+ )
+ super().__init__(*args, **kwargs)
+
+
+__all__ = ["MobileNetV2FeatureExtractor"]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/image_processing_mobilenet_v2.py b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/image_processing_mobilenet_v2.py
new file mode 100644
index 0000000000000000000000000000000000000000..c93f95a2058e05d3a418c2ced90ff2ef5c9ce795
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/image_processing_mobilenet_v2.py
@@ -0,0 +1,352 @@
+# coding=utf-8
+# Copyright 2022 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Image processor class for MobileNetV2."""
+
+from typing import Dict, List, Optional, Tuple, Union
+
+import numpy as np
+
+from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
+from ...image_transforms import (
+ get_resize_output_image_size,
+ resize,
+ to_channel_dimension_format,
+)
+from ...image_utils import (
+ IMAGENET_STANDARD_MEAN,
+ IMAGENET_STANDARD_STD,
+ ChannelDimension,
+ ImageInput,
+ PILImageResampling,
+ infer_channel_dimension_format,
+ is_scaled_image,
+ make_list_of_images,
+ to_numpy_array,
+ valid_images,
+ validate_preprocess_arguments,
+)
+from ...utils import TensorType, filter_out_non_signature_kwargs, is_torch_available, is_torch_tensor, logging
+
+
+if is_torch_available():
+ import torch
+
+
+logger = logging.get_logger(__name__)
+
+
+class MobileNetV2ImageProcessor(BaseImageProcessor):
+ r"""
+ Constructs a MobileNetV2 image processor.
+
+ Args:
+ do_resize (`bool`, *optional*, defaults to `True`):
+ Whether to resize the image's (height, width) dimensions to the specified `size`. Can be overridden by
+ `do_resize` in the `preprocess` method.
+ size (`Dict[str, int]` *optional*, defaults to `{"shortest_edge": 256}`):
+ Size of the image after resizing. The shortest edge of the image is resized to size["shortest_edge"], with
+ the longest edge resized to keep the input aspect ratio. Can be overridden by `size` in the `preprocess`
+ method.
+ resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BILINEAR`):
+ Resampling filter to use if resizing the image. Can be overridden by the `resample` parameter in the
+ `preprocess` method.
+ do_center_crop (`bool`, *optional*, defaults to `True`):
+ Whether to center crop the image. If the input size is smaller than `crop_size` along any edge, the image
+ is padded with 0's and then center cropped. Can be overridden by the `do_center_crop` parameter in the
+ `preprocess` method.
+ crop_size (`Dict[str, int]`, *optional*, defaults to `{"height": 224, "width": 224}`):
+ Desired output size when applying center-cropping. Only has an effect if `do_center_crop` is set to `True`.
+ Can be overridden by the `crop_size` parameter in the `preprocess` method.
+ do_rescale (`bool`, *optional*, defaults to `True`):
+ Whether to rescale the image by the specified scale `rescale_factor`. Can be overridden by the `do_rescale`
+ parameter in the `preprocess` method.
+ rescale_factor (`int` or `float`, *optional*, defaults to `1/255`):
+ Scale factor to use if rescaling the image. Can be overridden by the `rescale_factor` parameter in the
+ `preprocess` method.
+ do_normalize:
+ Whether to normalize the image. Can be overridden by the `do_normalize` parameter in the `preprocess`
+ method.
+ image_mean (`float` or `List[float]`, *optional*, defaults to `IMAGENET_STANDARD_MEAN`):
+ Mean to use if normalizing the image. This is a float or list of floats the length of the number of
+ channels in the image. Can be overridden by the `image_mean` parameter in the `preprocess` method.
+ image_std (`float` or `List[float]`, *optional*, defaults to `IMAGENET_STANDARD_STD`):
+ Standard deviation to use if normalizing the image. This is a float or list of floats the length of the
+ number of channels in the image. Can be overridden by the `image_std` parameter in the `preprocess` method.
+ """
+
+ model_input_names = ["pixel_values"]
+
+ def __init__(
+ self,
+ do_resize: bool = True,
+ size: Optional[Dict[str, int]] = None,
+ resample: PILImageResampling = PILImageResampling.BILINEAR,
+ do_center_crop: bool = True,
+ crop_size: Dict[str, int] = None,
+ do_rescale: bool = True,
+ rescale_factor: Union[int, float] = 1 / 255,
+ do_normalize: bool = True,
+ image_mean: Optional[Union[float, List[float]]] = None,
+ image_std: Optional[Union[float, List[float]]] = None,
+ **kwargs,
+ ) -> None:
+ super().__init__(**kwargs)
+ size = size if size is not None else {"shortest_edge": 256}
+ size = get_size_dict(size, default_to_square=False)
+ crop_size = crop_size if crop_size is not None else {"height": 224, "width": 224}
+ crop_size = get_size_dict(crop_size, param_name="crop_size")
+ self.do_resize = do_resize
+ self.size = size
+ self.resample = resample
+ self.do_center_crop = do_center_crop
+ self.crop_size = crop_size
+ self.do_rescale = do_rescale
+ self.rescale_factor = rescale_factor
+ self.do_normalize = do_normalize
+ self.image_mean = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
+ self.image_std = image_std if image_std is not None else IMAGENET_STANDARD_STD
+
+ # Copied from transformers.models.mobilenet_v1.image_processing_mobilenet_v1.MobileNetV1ImageProcessor.resize
+ def resize(
+ self,
+ image: np.ndarray,
+ size: Dict[str, int],
+ resample: PILImageResampling = PILImageResampling.BICUBIC,
+ data_format: Optional[Union[str, ChannelDimension]] = None,
+ input_data_format: Optional[Union[str, ChannelDimension]] = None,
+ **kwargs,
+ ) -> np.ndarray:
+ """
+ Resize an image. The shortest edge of the image is resized to size["shortest_edge"], with the longest edge
+ resized to keep the input aspect ratio.
+
+ Args:
+ image (`np.ndarray`):
+ Image to resize.
+ size (`Dict[str, int]`):
+ Size of the output image.
+ resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BICUBIC`):
+ Resampling filter to use when resiizing the image.
+ data_format (`str` or `ChannelDimension`, *optional*):
+ The channel dimension format of the image. If not provided, it will be the same as the input image.
+ input_data_format (`ChannelDimension` or `str`, *optional*):
+ The channel dimension format of the input image. If not provided, it will be inferred.
+ """
+ default_to_square = True
+ if "shortest_edge" in size:
+ size = size["shortest_edge"]
+ default_to_square = False
+ elif "height" in size and "width" in size:
+ size = (size["height"], size["width"])
+ else:
+ raise ValueError("Size must contain either 'shortest_edge' or 'height' and 'width'.")
+
+ output_size = get_resize_output_image_size(
+ image,
+ size=size,
+ default_to_square=default_to_square,
+ input_data_format=input_data_format,
+ )
+ return resize(
+ image,
+ size=output_size,
+ resample=resample,
+ data_format=data_format,
+ input_data_format=input_data_format,
+ **kwargs,
+ )
+
+ @filter_out_non_signature_kwargs()
+ def preprocess(
+ self,
+ images: ImageInput,
+ do_resize: Optional[bool] = None,
+ size: Dict[str, int] = None,
+ resample: PILImageResampling = None,
+ do_center_crop: bool = None,
+ crop_size: Dict[str, int] = None,
+ do_rescale: Optional[bool] = None,
+ rescale_factor: Optional[float] = None,
+ do_normalize: Optional[bool] = None,
+ image_mean: Optional[Union[float, List[float]]] = None,
+ image_std: Optional[Union[float, List[float]]] = None,
+ return_tensors: Optional[Union[str, TensorType]] = None,
+ data_format: Union[str, ChannelDimension] = ChannelDimension.FIRST,
+ input_data_format: Optional[Union[str, ChannelDimension]] = None,
+ ):
+ """
+ Preprocess an image or batch of images.
+
+ Args:
+ images (`ImageInput`):
+ Image to preprocess. Expects a single or batch of images with pixel values ranging from 0 to 255. If
+ passing in images with pixel values between 0 and 1, set `do_rescale=False`.
+ do_resize (`bool`, *optional*, defaults to `self.do_resize`):
+ Whether to resize the image.
+ size (`Dict[str, int]`, *optional*, defaults to `self.size`):
+ Size of the image after resizing. Shortest edge of the image is resized to size["shortest_edge"], with
+ the longest edge resized to keep the input aspect ratio.
+ resample (`PILImageResampling` filter, *optional*, defaults to `self.resample`):
+ `PILImageResampling` filter to use if resizing the image e.g. `PILImageResampling.BILINEAR`. Only has
+ an effect if `do_resize` is set to `True`.
+ do_center_crop (`bool`, *optional*, defaults to `self.do_center_crop`):
+ Whether to center crop the image.
+ crop_size (`Dict[str, int]`, *optional*, defaults to `self.crop_size`):
+ Size of the center crop. Only has an effect if `do_center_crop` is set to `True`.
+ do_rescale (`bool`, *optional*, defaults to `self.do_rescale`):
+ Whether to rescale the image values between [0 - 1].
+ rescale_factor (`float`, *optional*, defaults to `self.rescale_factor`):
+ Rescale factor to rescale the image by if `do_rescale` is set to `True`.
+ do_normalize (`bool`, *optional*, defaults to `self.do_normalize`):
+ Whether to normalize the image.
+ image_mean (`float` or `List[float]`, *optional*, defaults to `self.image_mean`):
+ Image mean to use if `do_normalize` is set to `True`.
+ image_std (`float` or `List[float]`, *optional*, defaults to `self.image_std`):
+ Image standard deviation to use if `do_normalize` is set to `True`.
+ return_tensors (`str` or `TensorType`, *optional*):
+ The type of tensors to return. Can be one of:
+ - Unset: Return a list of `np.ndarray`.
+ - `TensorType.TENSORFLOW` or `'tf'`: Return a batch of type `tf.Tensor`.
+ - `TensorType.PYTORCH` or `'pt'`: Return a batch of type `torch.Tensor`.
+ - `TensorType.NUMPY` or `'np'`: Return a batch of type `np.ndarray`.
+ - `TensorType.JAX` or `'jax'`: Return a batch of type `jax.numpy.ndarray`.
+ data_format (`ChannelDimension` or `str`, *optional*, defaults to `ChannelDimension.FIRST`):
+ The channel dimension format for the output image. Can be one of:
+ - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format.
+ - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format.
+ - Unset: Use the channel dimension format of the input image.
+ input_data_format (`ChannelDimension` or `str`, *optional*):
+ The channel dimension format for the input image. If unset, the channel dimension format is inferred
+ from the input image. Can be one of:
+ - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format.
+ - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format.
+ - `"none"` or `ChannelDimension.NONE`: image in (height, width) format.
+ """
+ do_resize = do_resize if do_resize is not None else self.do_resize
+ size = size if size is not None else self.size
+ size = get_size_dict(size, default_to_square=False)
+ resample = resample if resample is not None else self.resample
+ do_center_crop = do_center_crop if do_center_crop is not None else self.do_center_crop
+ crop_size = crop_size if crop_size is not None else self.crop_size
+ crop_size = get_size_dict(crop_size, param_name="crop_size")
+ do_rescale = do_rescale if do_rescale is not None else self.do_rescale
+ rescale_factor = rescale_factor if rescale_factor is not None else self.rescale_factor
+ do_normalize = do_normalize if do_normalize is not None else self.do_normalize
+ image_mean = image_mean if image_mean is not None else self.image_mean
+ image_std = image_std if image_std is not None else self.image_std
+
+ images = make_list_of_images(images)
+
+ if not valid_images(images):
+ raise ValueError(
+ "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
+ "torch.Tensor, tf.Tensor or jax.ndarray."
+ )
+ validate_preprocess_arguments(
+ do_rescale=do_rescale,
+ rescale_factor=rescale_factor,
+ do_normalize=do_normalize,
+ image_mean=image_mean,
+ image_std=image_std,
+ do_center_crop=do_center_crop,
+ crop_size=crop_size,
+ do_resize=do_resize,
+ size=size,
+ resample=resample,
+ )
+ # All transformations expect numpy arrays.
+ images = [to_numpy_array(image) for image in images]
+
+ if do_rescale and is_scaled_image(images[0]):
+ logger.warning_once(
+ "It looks like you are trying to rescale already rescaled images. If the input"
+ " images have pixel values between 0 and 1, set `do_rescale=False` to avoid rescaling them again."
+ )
+
+ if input_data_format is None:
+ # We assume that all images have the same channel dimension format.
+ input_data_format = infer_channel_dimension_format(images[0])
+
+ all_images = []
+ for image in images:
+ if do_resize:
+ image = self.resize(image=image, size=size, resample=resample, input_data_format=input_data_format)
+
+ if do_center_crop:
+ image = self.center_crop(image=image, size=crop_size, input_data_format=input_data_format)
+
+ if do_rescale:
+ image = self.rescale(image=image, scale=rescale_factor, input_data_format=input_data_format)
+
+ if do_normalize:
+ image = self.normalize(
+ image=image, mean=image_mean, std=image_std, input_data_format=input_data_format
+ )
+
+ all_images.append(image)
+ images = [
+ to_channel_dimension_format(image, data_format, input_channel_dim=input_data_format)
+ for image in all_images
+ ]
+
+ data = {"pixel_values": images}
+ return BatchFeature(data=data, tensor_type=return_tensors)
+
+ # Copied from transformers.models.beit.image_processing_beit.BeitImageProcessor.post_process_semantic_segmentation with Beit->MobileNetV2
+ def post_process_semantic_segmentation(self, outputs, target_sizes: List[Tuple] = None):
+ """
+ Converts the output of [`MobileNetV2ForSemanticSegmentation`] into semantic segmentation maps. Only supports PyTorch.
+
+ Args:
+ outputs ([`MobileNetV2ForSemanticSegmentation`]):
+ Raw outputs of the model.
+ target_sizes (`List[Tuple]` of length `batch_size`, *optional*):
+ List of tuples corresponding to the requested final size (height, width) of each prediction. If unset,
+ predictions will not be resized.
+
+ Returns:
+ semantic_segmentation: `List[torch.Tensor]` of length `batch_size`, where each item is a semantic
+ segmentation map of shape (height, width) corresponding to the target_sizes entry (if `target_sizes` is
+ specified). Each entry of each `torch.Tensor` correspond to a semantic class id.
+ """
+ # TODO: add support for other frameworks
+ logits = outputs.logits
+
+ # Resize logits and compute semantic segmentation maps
+ if target_sizes is not None:
+ if len(logits) != len(target_sizes):
+ raise ValueError(
+ "Make sure that you pass in as many target sizes as the batch dimension of the logits"
+ )
+
+ if is_torch_tensor(target_sizes):
+ target_sizes = target_sizes.numpy()
+
+ semantic_segmentation = []
+
+ for idx in range(len(logits)):
+ resized_logits = torch.nn.functional.interpolate(
+ logits[idx].unsqueeze(dim=0), size=target_sizes[idx], mode="bilinear", align_corners=False
+ )
+ semantic_map = resized_logits[0].argmax(dim=0)
+ semantic_segmentation.append(semantic_map)
+ else:
+ semantic_segmentation = logits.argmax(dim=1)
+ semantic_segmentation = [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0])]
+
+ return semantic_segmentation
+
+
+__all__ = ["MobileNetV2ImageProcessor"]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/modeling_mobilenet_v2.py b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/modeling_mobilenet_v2.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd36d111f8af174a09f3211a969bb396c5e274e6
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/mobilenet_v2/modeling_mobilenet_v2.py
@@ -0,0 +1,868 @@
+# coding=utf-8
+# Copyright 2022 Apple Inc. and The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""PyTorch MobileNetV2 model."""
+
+from typing import Optional, Union
+
+import torch
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+
+from ...activations import ACT2FN
+from ...modeling_outputs import (
+ BaseModelOutputWithPoolingAndNoAttention,
+ ImageClassifierOutputWithNoAttention,
+ SemanticSegmenterOutput,
+)
+from ...modeling_utils import PreTrainedModel
+from ...utils import (
+ add_code_sample_docstrings,
+ add_start_docstrings,
+ add_start_docstrings_to_model_forward,
+ logging,
+ replace_return_docstrings,
+)
+from .configuration_mobilenet_v2 import MobileNetV2Config
+
+
+logger = logging.get_logger(__name__)
+
+
+# General docstring
+_CONFIG_FOR_DOC = "MobileNetV2Config"
+
+# Base docstring
+_CHECKPOINT_FOR_DOC = "google/mobilenet_v2_1.0_224"
+_EXPECTED_OUTPUT_SHAPE = [1, 1280, 7, 7]
+
+# Image classification docstring
+_IMAGE_CLASS_CHECKPOINT = "google/mobilenet_v2_1.0_224"
+_IMAGE_CLASS_EXPECTED_OUTPUT = "tabby, tabby cat"
+
+
+def _build_tf_to_pytorch_map(model, config, tf_weights=None):
+ """
+ A map of modules from TF to PyTorch.
+ """
+
+ tf_to_pt_map = {}
+
+ if isinstance(model, (MobileNetV2ForImageClassification, MobileNetV2ForSemanticSegmentation)):
+ backbone = model.mobilenet_v2
+ else:
+ backbone = model
+
+ # Use the EMA weights if available
+ def ema(x):
+ return x + "/ExponentialMovingAverage" if x + "/ExponentialMovingAverage" in tf_weights else x
+
+ prefix = "MobilenetV2/Conv/"
+ tf_to_pt_map[ema(prefix + "weights")] = backbone.conv_stem.first_conv.convolution.weight
+ tf_to_pt_map[ema(prefix + "BatchNorm/beta")] = backbone.conv_stem.first_conv.normalization.bias
+ tf_to_pt_map[ema(prefix + "BatchNorm/gamma")] = backbone.conv_stem.first_conv.normalization.weight
+ tf_to_pt_map[prefix + "BatchNorm/moving_mean"] = backbone.conv_stem.first_conv.normalization.running_mean
+ tf_to_pt_map[prefix + "BatchNorm/moving_variance"] = backbone.conv_stem.first_conv.normalization.running_var
+
+ prefix = "MobilenetV2/expanded_conv/depthwise/"
+ tf_to_pt_map[ema(prefix + "depthwise_weights")] = backbone.conv_stem.conv_3x3.convolution.weight
+ tf_to_pt_map[ema(prefix + "BatchNorm/beta")] = backbone.conv_stem.conv_3x3.normalization.bias
+ tf_to_pt_map[ema(prefix + "BatchNorm/gamma")] = backbone.conv_stem.conv_3x3.normalization.weight
+ tf_to_pt_map[prefix + "BatchNorm/moving_mean"] = backbone.conv_stem.conv_3x3.normalization.running_mean
+ tf_to_pt_map[prefix + "BatchNorm/moving_variance"] = backbone.conv_stem.conv_3x3.normalization.running_var
+
+ prefix = "MobilenetV2/expanded_conv/project/"
+ tf_to_pt_map[ema(prefix + "weights")] = backbone.conv_stem.reduce_1x1.convolution.weight
+ tf_to_pt_map[ema(prefix + "BatchNorm/beta")] = backbone.conv_stem.reduce_1x1.normalization.bias
+ tf_to_pt_map[ema(prefix + "BatchNorm/gamma")] = backbone.conv_stem.reduce_1x1.normalization.weight
+ tf_to_pt_map[prefix + "BatchNorm/moving_mean"] = backbone.conv_stem.reduce_1x1.normalization.running_mean
+ tf_to_pt_map[prefix + "BatchNorm/moving_variance"] = backbone.conv_stem.reduce_1x1.normalization.running_var
+
+ for i in range(16):
+ tf_index = i + 1
+ pt_index = i
+ pointer = backbone.layer[pt_index]
+
+ prefix = f"MobilenetV2/expanded_conv_{tf_index}/expand/"
+ tf_to_pt_map[ema(prefix + "weights")] = pointer.expand_1x1.convolution.weight
+ tf_to_pt_map[ema(prefix + "BatchNorm/beta")] = pointer.expand_1x1.normalization.bias
+ tf_to_pt_map[ema(prefix + "BatchNorm/gamma")] = pointer.expand_1x1.normalization.weight
+ tf_to_pt_map[prefix + "BatchNorm/moving_mean"] = pointer.expand_1x1.normalization.running_mean
+ tf_to_pt_map[prefix + "BatchNorm/moving_variance"] = pointer.expand_1x1.normalization.running_var
+
+ prefix = f"MobilenetV2/expanded_conv_{tf_index}/depthwise/"
+ tf_to_pt_map[ema(prefix + "depthwise_weights")] = pointer.conv_3x3.convolution.weight
+ tf_to_pt_map[ema(prefix + "BatchNorm/beta")] = pointer.conv_3x3.normalization.bias
+ tf_to_pt_map[ema(prefix + "BatchNorm/gamma")] = pointer.conv_3x3.normalization.weight
+ tf_to_pt_map[prefix + "BatchNorm/moving_mean"] = pointer.conv_3x3.normalization.running_mean
+ tf_to_pt_map[prefix + "BatchNorm/moving_variance"] = pointer.conv_3x3.normalization.running_var
+
+ prefix = f"MobilenetV2/expanded_conv_{tf_index}/project/"
+ tf_to_pt_map[ema(prefix + "weights")] = pointer.reduce_1x1.convolution.weight
+ tf_to_pt_map[ema(prefix + "BatchNorm/beta")] = pointer.reduce_1x1.normalization.bias
+ tf_to_pt_map[ema(prefix + "BatchNorm/gamma")] = pointer.reduce_1x1.normalization.weight
+ tf_to_pt_map[prefix + "BatchNorm/moving_mean"] = pointer.reduce_1x1.normalization.running_mean
+ tf_to_pt_map[prefix + "BatchNorm/moving_variance"] = pointer.reduce_1x1.normalization.running_var
+
+ prefix = "MobilenetV2/Conv_1/"
+ tf_to_pt_map[ema(prefix + "weights")] = backbone.conv_1x1.convolution.weight
+ tf_to_pt_map[ema(prefix + "BatchNorm/beta")] = backbone.conv_1x1.normalization.bias
+ tf_to_pt_map[ema(prefix + "BatchNorm/gamma")] = backbone.conv_1x1.normalization.weight
+ tf_to_pt_map[prefix + "BatchNorm/moving_mean"] = backbone.conv_1x1.normalization.running_mean
+ tf_to_pt_map[prefix + "BatchNorm/moving_variance"] = backbone.conv_1x1.normalization.running_var
+
+ if isinstance(model, MobileNetV2ForImageClassification):
+ prefix = "MobilenetV2/Logits/Conv2d_1c_1x1/"
+ tf_to_pt_map[ema(prefix + "weights")] = model.classifier.weight
+ tf_to_pt_map[ema(prefix + "biases")] = model.classifier.bias
+
+ if isinstance(model, MobileNetV2ForSemanticSegmentation):
+ prefix = "image_pooling/"
+ tf_to_pt_map[prefix + "weights"] = model.segmentation_head.conv_pool.convolution.weight
+ tf_to_pt_map[prefix + "BatchNorm/beta"] = model.segmentation_head.conv_pool.normalization.bias
+ tf_to_pt_map[prefix + "BatchNorm/gamma"] = model.segmentation_head.conv_pool.normalization.weight
+ tf_to_pt_map[prefix + "BatchNorm/moving_mean"] = model.segmentation_head.conv_pool.normalization.running_mean
+ tf_to_pt_map[prefix + "BatchNorm/moving_variance"] = (
+ model.segmentation_head.conv_pool.normalization.running_var
+ )
+
+ prefix = "aspp0/"
+ tf_to_pt_map[prefix + "weights"] = model.segmentation_head.conv_aspp.convolution.weight
+ tf_to_pt_map[prefix + "BatchNorm/beta"] = model.segmentation_head.conv_aspp.normalization.bias
+ tf_to_pt_map[prefix + "BatchNorm/gamma"] = model.segmentation_head.conv_aspp.normalization.weight
+ tf_to_pt_map[prefix + "BatchNorm/moving_mean"] = model.segmentation_head.conv_aspp.normalization.running_mean
+ tf_to_pt_map[prefix + "BatchNorm/moving_variance"] = (
+ model.segmentation_head.conv_aspp.normalization.running_var
+ )
+
+ prefix = "concat_projection/"
+ tf_to_pt_map[prefix + "weights"] = model.segmentation_head.conv_projection.convolution.weight
+ tf_to_pt_map[prefix + "BatchNorm/beta"] = model.segmentation_head.conv_projection.normalization.bias
+ tf_to_pt_map[prefix + "BatchNorm/gamma"] = model.segmentation_head.conv_projection.normalization.weight
+ tf_to_pt_map[prefix + "BatchNorm/moving_mean"] = (
+ model.segmentation_head.conv_projection.normalization.running_mean
+ )
+ tf_to_pt_map[prefix + "BatchNorm/moving_variance"] = (
+ model.segmentation_head.conv_projection.normalization.running_var
+ )
+
+ prefix = "logits/semantic/"
+ tf_to_pt_map[ema(prefix + "weights")] = model.segmentation_head.classifier.convolution.weight
+ tf_to_pt_map[ema(prefix + "biases")] = model.segmentation_head.classifier.convolution.bias
+
+ return tf_to_pt_map
+
+
+def load_tf_weights_in_mobilenet_v2(model, config, tf_checkpoint_path):
+ """Load TensorFlow checkpoints in a PyTorch model."""
+ try:
+ import numpy as np
+ import tensorflow as tf
+ except ImportError:
+ logger.error(
+ "Loading a TensorFlow models in PyTorch, requires TensorFlow to be installed. Please see "
+ "https://www.tensorflow.org/install/ for installation instructions."
+ )
+ raise
+
+ # Load weights from TF model
+ init_vars = tf.train.list_variables(tf_checkpoint_path)
+ tf_weights = {}
+ for name, shape in init_vars:
+ logger.info(f"Loading TF weight {name} with shape {shape}")
+ array = tf.train.load_variable(tf_checkpoint_path, name)
+ tf_weights[name] = array
+
+ # Build TF to PyTorch weights loading map
+ tf_to_pt_map = _build_tf_to_pytorch_map(model, config, tf_weights)
+
+ for name, pointer in tf_to_pt_map.items():
+ logger.info(f"Importing {name}")
+ if name not in tf_weights:
+ logger.info(f"{name} not in tf pre-trained weights, skipping")
+ continue
+
+ array = tf_weights[name]
+
+ if "depthwise_weights" in name:
+ logger.info("Transposing depthwise")
+ array = np.transpose(array, (2, 3, 0, 1))
+ elif "weights" in name:
+ logger.info("Transposing")
+ if len(pointer.shape) == 2: # copying into linear layer
+ array = array.squeeze().transpose()
+ else:
+ array = np.transpose(array, (3, 2, 0, 1))
+
+ if pointer.shape != array.shape:
+ raise ValueError(f"Pointer shape {pointer.shape} and array shape {array.shape} mismatched")
+
+ logger.info(f"Initialize PyTorch weight {name} {array.shape}")
+ pointer.data = torch.from_numpy(array)
+
+ tf_weights.pop(name, None)
+ tf_weights.pop(name + "/RMSProp", None)
+ tf_weights.pop(name + "/RMSProp_1", None)
+ tf_weights.pop(name + "/ExponentialMovingAverage", None)
+ tf_weights.pop(name + "/Momentum", None)
+
+ logger.info(f"Weights not copied to PyTorch model: {', '.join(tf_weights.keys())}")
+ return model
+
+
+def make_divisible(value: int, divisor: int = 8, min_value: Optional[int] = None) -> int:
+ """
+ Ensure that all layers have a channel count that is divisible by `divisor`. This function is taken from the
+ original TensorFlow repo. It can be seen here:
+ https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py
+ """
+ if min_value is None:
+ min_value = divisor
+ new_value = max(min_value, int(value + divisor / 2) // divisor * divisor)
+ # Make sure that round down does not go down by more than 10%.
+ if new_value < 0.9 * value:
+ new_value += divisor
+ return int(new_value)
+
+
+def apply_depth_multiplier(config: MobileNetV2Config, channels: int) -> int:
+ return make_divisible(int(round(channels * config.depth_multiplier)), config.depth_divisible_by, config.min_depth)
+
+
+def apply_tf_padding(features: torch.Tensor, conv_layer: nn.Conv2d) -> torch.Tensor:
+ """
+ Apply TensorFlow-style "SAME" padding to a convolution layer. See the notes at:
+ https://www.tensorflow.org/api_docs/python/tf/nn#notes_on_padding_2
+ """
+ in_height = int(features.shape[-2])
+ in_width = int(features.shape[-1])
+ stride_height, stride_width = conv_layer.stride
+ kernel_height, kernel_width = conv_layer.kernel_size
+ dilation_height, dilation_width = conv_layer.dilation
+
+ if in_height % stride_height == 0:
+ pad_along_height = max(kernel_height - stride_height, 0)
+ else:
+ pad_along_height = max(kernel_height - (in_height % stride_height), 0)
+
+ if in_width % stride_width == 0:
+ pad_along_width = max(kernel_width - stride_width, 0)
+ else:
+ pad_along_width = max(kernel_width - (in_width % stride_width), 0)
+
+ pad_left = pad_along_width // 2
+ pad_right = pad_along_width - pad_left
+ pad_top = pad_along_height // 2
+ pad_bottom = pad_along_height - pad_top
+
+ padding = (
+ pad_left * dilation_width,
+ pad_right * dilation_width,
+ pad_top * dilation_height,
+ pad_bottom * dilation_height,
+ )
+ return nn.functional.pad(features, padding, "constant", 0.0)
+
+
+class MobileNetV2ConvLayer(nn.Module):
+ def __init__(
+ self,
+ config: MobileNetV2Config,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: int,
+ stride: int = 1,
+ groups: int = 1,
+ bias: bool = False,
+ dilation: int = 1,
+ use_normalization: bool = True,
+ use_activation: Union[bool, str] = True,
+ layer_norm_eps: Optional[float] = None,
+ ) -> None:
+ super().__init__()
+ self.config = config
+
+ if in_channels % groups != 0:
+ raise ValueError(f"Input channels ({in_channels}) are not divisible by {groups} groups.")
+ if out_channels % groups != 0:
+ raise ValueError(f"Output channels ({out_channels}) are not divisible by {groups} groups.")
+
+ padding = 0 if config.tf_padding else int((kernel_size - 1) / 2) * dilation
+
+ self.convolution = nn.Conv2d(
+ in_channels=in_channels,
+ out_channels=out_channels,
+ kernel_size=kernel_size,
+ stride=stride,
+ padding=padding,
+ dilation=dilation,
+ groups=groups,
+ bias=bias,
+ padding_mode="zeros",
+ )
+
+ if use_normalization:
+ self.normalization = nn.BatchNorm2d(
+ num_features=out_channels,
+ eps=config.layer_norm_eps if layer_norm_eps is None else layer_norm_eps,
+ momentum=0.997,
+ affine=True,
+ track_running_stats=True,
+ )
+ else:
+ self.normalization = None
+
+ if use_activation:
+ if isinstance(use_activation, str):
+ self.activation = ACT2FN[use_activation]
+ elif isinstance(config.hidden_act, str):
+ self.activation = ACT2FN[config.hidden_act]
+ else:
+ self.activation = config.hidden_act
+ else:
+ self.activation = None
+
+ def forward(self, features: torch.Tensor) -> torch.Tensor:
+ if self.config.tf_padding:
+ features = apply_tf_padding(features, self.convolution)
+ features = self.convolution(features)
+ if self.normalization is not None:
+ features = self.normalization(features)
+ if self.activation is not None:
+ features = self.activation(features)
+ return features
+
+
+class MobileNetV2InvertedResidual(nn.Module):
+ def __init__(
+ self, config: MobileNetV2Config, in_channels: int, out_channels: int, stride: int, dilation: int = 1
+ ) -> None:
+ super().__init__()
+
+ expanded_channels = make_divisible(
+ int(round(in_channels * config.expand_ratio)), config.depth_divisible_by, config.min_depth
+ )
+
+ if stride not in [1, 2]:
+ raise ValueError(f"Invalid stride {stride}.")
+
+ self.use_residual = (stride == 1) and (in_channels == out_channels)
+
+ self.expand_1x1 = MobileNetV2ConvLayer(
+ config, in_channels=in_channels, out_channels=expanded_channels, kernel_size=1
+ )
+
+ self.conv_3x3 = MobileNetV2ConvLayer(
+ config,
+ in_channels=expanded_channels,
+ out_channels=expanded_channels,
+ kernel_size=3,
+ stride=stride,
+ groups=expanded_channels,
+ dilation=dilation,
+ )
+
+ self.reduce_1x1 = MobileNetV2ConvLayer(
+ config,
+ in_channels=expanded_channels,
+ out_channels=out_channels,
+ kernel_size=1,
+ use_activation=False,
+ )
+
+ def forward(self, features: torch.Tensor) -> torch.Tensor:
+ residual = features
+
+ features = self.expand_1x1(features)
+ features = self.conv_3x3(features)
+ features = self.reduce_1x1(features)
+
+ return residual + features if self.use_residual else features
+
+
+class MobileNetV2Stem(nn.Module):
+ def __init__(self, config: MobileNetV2Config, in_channels: int, expanded_channels: int, out_channels: int) -> None:
+ super().__init__()
+
+ # The very first layer is a regular 3x3 convolution with stride 2 that expands to 32 channels.
+ # All other expansion layers use the expansion factor to compute the number of output channels.
+ self.first_conv = MobileNetV2ConvLayer(
+ config,
+ in_channels=in_channels,
+ out_channels=expanded_channels,
+ kernel_size=3,
+ stride=2,
+ )
+
+ if config.first_layer_is_expansion:
+ self.expand_1x1 = None
+ else:
+ self.expand_1x1 = MobileNetV2ConvLayer(
+ config, in_channels=expanded_channels, out_channels=expanded_channels, kernel_size=1
+ )
+
+ self.conv_3x3 = MobileNetV2ConvLayer(
+ config,
+ in_channels=expanded_channels,
+ out_channels=expanded_channels,
+ kernel_size=3,
+ stride=1,
+ groups=expanded_channels,
+ )
+
+ self.reduce_1x1 = MobileNetV2ConvLayer(
+ config,
+ in_channels=expanded_channels,
+ out_channels=out_channels,
+ kernel_size=1,
+ use_activation=False,
+ )
+
+ def forward(self, features: torch.Tensor) -> torch.Tensor:
+ features = self.first_conv(features)
+ if self.expand_1x1 is not None:
+ features = self.expand_1x1(features)
+ features = self.conv_3x3(features)
+ features = self.reduce_1x1(features)
+ return features
+
+
+class MobileNetV2PreTrainedModel(PreTrainedModel):
+ """
+ An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+ models.
+ """
+
+ config_class = MobileNetV2Config
+ load_tf_weights = load_tf_weights_in_mobilenet_v2
+ base_model_prefix = "mobilenet_v2"
+ main_input_name = "pixel_values"
+ supports_gradient_checkpointing = False
+ _no_split_modules = []
+
+ def _init_weights(self, module: Union[nn.Linear, nn.Conv2d]) -> None:
+ """Initialize the weights"""
+ if isinstance(module, (nn.Linear, nn.Conv2d)):
+ module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+ if module.bias is not None:
+ module.bias.data.zero_()
+ elif isinstance(module, nn.BatchNorm2d):
+ module.bias.data.zero_()
+ module.weight.data.fill_(1.0)
+
+
+MOBILENET_V2_START_DOCSTRING = r"""
+ This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it
+ as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
+ behavior.
+
+ Parameters:
+ config ([`MobileNetV2Config`]): Model configuration class with all the parameters of the model.
+ Initializing with a config file does not load the weights associated with the model, only the
+ configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+"""
+
+MOBILENET_V2_INPUTS_DOCSTRING = r"""
+ Args:
+ pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
+ Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
+ [`MobileNetV2ImageProcessor.__call__`] for details.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+ more detail.
+ return_dict (`bool`, *optional*):
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+"""
+
+
+@add_start_docstrings(
+ "The bare MobileNetV2 model outputting raw hidden-states without any specific head on top.",
+ MOBILENET_V2_START_DOCSTRING,
+)
+class MobileNetV2Model(MobileNetV2PreTrainedModel):
+ def __init__(self, config: MobileNetV2Config, add_pooling_layer: bool = True):
+ super().__init__(config)
+ self.config = config
+
+ # Output channels for the projection layers
+ channels = [16, 24, 24, 32, 32, 32, 64, 64, 64, 64, 96, 96, 96, 160, 160, 160, 320]
+ channels = [apply_depth_multiplier(config, x) for x in channels]
+
+ # Strides for the depthwise layers
+ strides = [2, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1]
+
+ self.conv_stem = MobileNetV2Stem(
+ config,
+ in_channels=config.num_channels,
+ expanded_channels=apply_depth_multiplier(config, 32),
+ out_channels=channels[0],
+ )
+
+ current_stride = 2 # first conv layer has stride 2
+ dilation = 1
+
+ self.layer = nn.ModuleList()
+ for i in range(16):
+ # Keep making the feature maps smaller or use dilated convolution?
+ if current_stride == config.output_stride:
+ layer_stride = 1
+ layer_dilation = dilation
+ dilation *= strides[i] # larger dilation starts in next block
+ else:
+ layer_stride = strides[i]
+ layer_dilation = 1
+ current_stride *= layer_stride
+
+ self.layer.append(
+ MobileNetV2InvertedResidual(
+ config,
+ in_channels=channels[i],
+ out_channels=channels[i + 1],
+ stride=layer_stride,
+ dilation=layer_dilation,
+ )
+ )
+
+ if config.finegrained_output and config.depth_multiplier < 1.0:
+ output_channels = 1280
+ else:
+ output_channels = apply_depth_multiplier(config, 1280)
+
+ self.conv_1x1 = MobileNetV2ConvLayer(
+ config,
+ in_channels=channels[-1],
+ out_channels=output_channels,
+ kernel_size=1,
+ )
+
+ self.pooler = nn.AdaptiveAvgPool2d((1, 1)) if add_pooling_layer else None
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def _prune_heads(self, heads_to_prune):
+ raise NotImplementedError
+
+ @add_start_docstrings_to_model_forward(MOBILENET_V2_INPUTS_DOCSTRING)
+ @add_code_sample_docstrings(
+ checkpoint=_CHECKPOINT_FOR_DOC,
+ output_type=BaseModelOutputWithPoolingAndNoAttention,
+ config_class=_CONFIG_FOR_DOC,
+ modality="vision",
+ expected_output=_EXPECTED_OUTPUT_SHAPE,
+ )
+ def forward(
+ self,
+ pixel_values: Optional[torch.Tensor] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ ) -> Union[tuple, BaseModelOutputWithPoolingAndNoAttention]:
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+ if pixel_values is None:
+ raise ValueError("You have to specify pixel_values")
+
+ hidden_states = self.conv_stem(pixel_values)
+
+ all_hidden_states = () if output_hidden_states else None
+
+ for i, layer_module in enumerate(self.layer):
+ hidden_states = layer_module(hidden_states)
+
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ last_hidden_state = self.conv_1x1(hidden_states)
+
+ if self.pooler is not None:
+ pooled_output = torch.flatten(self.pooler(last_hidden_state), start_dim=1)
+ else:
+ pooled_output = None
+
+ if not return_dict:
+ return tuple(v for v in [last_hidden_state, pooled_output, all_hidden_states] if v is not None)
+
+ return BaseModelOutputWithPoolingAndNoAttention(
+ last_hidden_state=last_hidden_state,
+ pooler_output=pooled_output,
+ hidden_states=all_hidden_states,
+ )
+
+
+@add_start_docstrings(
+ """
+ MobileNetV2 model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
+ ImageNet.
+ """,
+ MOBILENET_V2_START_DOCSTRING,
+)
+class MobileNetV2ForImageClassification(MobileNetV2PreTrainedModel):
+ def __init__(self, config: MobileNetV2Config) -> None:
+ super().__init__(config)
+
+ self.num_labels = config.num_labels
+ self.mobilenet_v2 = MobileNetV2Model(config)
+
+ last_hidden_size = self.mobilenet_v2.conv_1x1.convolution.out_channels
+
+ # Classifier head
+ self.dropout = nn.Dropout(config.classifier_dropout_prob, inplace=True)
+ self.classifier = nn.Linear(last_hidden_size, config.num_labels) if config.num_labels > 0 else nn.Identity()
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @add_start_docstrings_to_model_forward(MOBILENET_V2_INPUTS_DOCSTRING)
+ @add_code_sample_docstrings(
+ checkpoint=_CHECKPOINT_FOR_DOC,
+ output_type=ImageClassifierOutputWithNoAttention,
+ config_class=_CONFIG_FOR_DOC,
+ expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT,
+ )
+ def forward(
+ self,
+ pixel_values: Optional[torch.Tensor] = None,
+ output_hidden_states: Optional[bool] = None,
+ labels: Optional[torch.Tensor] = None,
+ return_dict: Optional[bool] = None,
+ ) -> Union[tuple, ImageClassifierOutputWithNoAttention]:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss). If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+ outputs = self.mobilenet_v2(pixel_values, output_hidden_states=output_hidden_states, return_dict=return_dict)
+
+ pooled_output = outputs.pooler_output if return_dict else outputs[1]
+
+ logits = self.classifier(self.dropout(pooled_output))
+
+ loss = None
+ if labels is not None:
+ if self.config.problem_type is None:
+ if self.num_labels == 1:
+ self.config.problem_type = "regression"
+ elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+ self.config.problem_type = "single_label_classification"
+ else:
+ self.config.problem_type = "multi_label_classification"
+
+ if self.config.problem_type == "regression":
+ loss_fct = MSELoss()
+ if self.num_labels == 1:
+ loss = loss_fct(logits.squeeze(), labels.squeeze())
+ else:
+ loss = loss_fct(logits, labels)
+ elif self.config.problem_type == "single_label_classification":
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+ elif self.config.problem_type == "multi_label_classification":
+ loss_fct = BCEWithLogitsLoss()
+ loss = loss_fct(logits, labels)
+
+ if not return_dict:
+ output = (logits,) + outputs[2:]
+ return ((loss,) + output) if loss is not None else output
+
+ return ImageClassifierOutputWithNoAttention(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ )
+
+
+class MobileNetV2DeepLabV3Plus(nn.Module):
+ """
+ The neural network from the paper "Encoder-Decoder with Atrous Separable Convolution for Semantic Image
+ Segmentation" https://arxiv.org/abs/1802.02611
+ """
+
+ def __init__(self, config: MobileNetV2Config) -> None:
+ super().__init__()
+
+ self.avg_pool = nn.AdaptiveAvgPool2d(output_size=1)
+
+ self.conv_pool = MobileNetV2ConvLayer(
+ config,
+ in_channels=apply_depth_multiplier(config, 320),
+ out_channels=256,
+ kernel_size=1,
+ stride=1,
+ use_normalization=True,
+ use_activation="relu",
+ layer_norm_eps=1e-5,
+ )
+
+ self.conv_aspp = MobileNetV2ConvLayer(
+ config,
+ in_channels=apply_depth_multiplier(config, 320),
+ out_channels=256,
+ kernel_size=1,
+ stride=1,
+ use_normalization=True,
+ use_activation="relu",
+ layer_norm_eps=1e-5,
+ )
+
+ self.conv_projection = MobileNetV2ConvLayer(
+ config,
+ in_channels=512,
+ out_channels=256,
+ kernel_size=1,
+ stride=1,
+ use_normalization=True,
+ use_activation="relu",
+ layer_norm_eps=1e-5,
+ )
+
+ self.dropout = nn.Dropout2d(config.classifier_dropout_prob)
+
+ self.classifier = MobileNetV2ConvLayer(
+ config,
+ in_channels=256,
+ out_channels=config.num_labels,
+ kernel_size=1,
+ use_normalization=False,
+ use_activation=False,
+ bias=True,
+ )
+
+ def forward(self, features: torch.Tensor) -> torch.Tensor:
+ spatial_size = features.shape[-2:]
+
+ features_pool = self.avg_pool(features)
+ features_pool = self.conv_pool(features_pool)
+ features_pool = nn.functional.interpolate(
+ features_pool, size=spatial_size, mode="bilinear", align_corners=True
+ )
+
+ features_aspp = self.conv_aspp(features)
+
+ features = torch.cat([features_pool, features_aspp], dim=1)
+
+ features = self.conv_projection(features)
+ features = self.dropout(features)
+ features = self.classifier(features)
+ return features
+
+
+@add_start_docstrings(
+ """
+ MobileNetV2 model with a semantic segmentation head on top, e.g. for Pascal VOC.
+ """,
+ MOBILENET_V2_START_DOCSTRING,
+)
+class MobileNetV2ForSemanticSegmentation(MobileNetV2PreTrainedModel):
+ def __init__(self, config: MobileNetV2Config) -> None:
+ super().__init__(config)
+
+ self.num_labels = config.num_labels
+ self.mobilenet_v2 = MobileNetV2Model(config, add_pooling_layer=False)
+ self.segmentation_head = MobileNetV2DeepLabV3Plus(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @add_start_docstrings_to_model_forward(MOBILENET_V2_INPUTS_DOCSTRING)
+ @replace_return_docstrings(output_type=SemanticSegmenterOutput, config_class=_CONFIG_FOR_DOC)
+ def forward(
+ self,
+ pixel_values: Optional[torch.Tensor] = None,
+ labels: Optional[torch.Tensor] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ ) -> Union[tuple, SemanticSegmenterOutput]:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size, height, width)`, *optional*):
+ Ground truth semantic segmentation maps for computing the loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels > 1`, a classification loss is computed (Cross-Entropy).
+
+ Returns:
+
+ Examples:
+
+ ```python
+ >>> from transformers import AutoImageProcessor, MobileNetV2ForSemanticSegmentation
+ >>> from PIL import Image
+ >>> import requests
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> image = Image.open(requests.get(url, stream=True).raw)
+
+ >>> image_processor = AutoImageProcessor.from_pretrained("google/deeplabv3_mobilenet_v2_1.0_513")
+ >>> model = MobileNetV2ForSemanticSegmentation.from_pretrained("google/deeplabv3_mobilenet_v2_1.0_513")
+
+ >>> inputs = image_processor(images=image, return_tensors="pt")
+
+ >>> with torch.no_grad():
+ ... outputs = model(**inputs)
+
+ >>> # logits are of shape (batch_size, num_labels, height, width)
+ >>> logits = outputs.logits
+ ```"""
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+ if labels is not None and self.config.num_labels == 1:
+ raise ValueError("The number of labels should be greater than one")
+
+ outputs = self.mobilenet_v2(
+ pixel_values,
+ output_hidden_states=True, # we need the intermediate hidden states
+ return_dict=return_dict,
+ )
+
+ encoder_hidden_states = outputs.hidden_states if return_dict else outputs[1]
+
+ logits = self.segmentation_head(encoder_hidden_states[-1])
+
+ loss = None
+ if labels is not None:
+ # upsample logits to the images' original size
+ upsampled_logits = nn.functional.interpolate(
+ logits, size=labels.shape[-2:], mode="bilinear", align_corners=False
+ )
+ loss_fct = CrossEntropyLoss(ignore_index=self.config.semantic_loss_ignore_index)
+ loss = loss_fct(upsampled_logits, labels)
+
+ if not return_dict:
+ if output_hidden_states:
+ output = (logits,) + outputs[1:]
+ else:
+ output = (logits,) + outputs[2:]
+ return ((loss,) + output) if loss is not None else output
+
+ return SemanticSegmenterOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states if output_hidden_states else None,
+ attentions=None,
+ )
+
+
+__all__ = [
+ "MobileNetV2ForImageClassification",
+ "MobileNetV2ForSemanticSegmentation",
+ "MobileNetV2Model",
+ "MobileNetV2PreTrainedModel",
+ "load_tf_weights_in_mobilenet_v2",
+]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/modernbert/__init__.py b/vllm/lib/python3.10/site-packages/transformers/models/modernbert/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..18317742981909460973138da806584ddfc4a390
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/modernbert/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import TYPE_CHECKING
+
+from ...utils import _LazyModule
+from ...utils.import_utils import define_import_structure
+
+
+if TYPE_CHECKING:
+ from .configuration_modernbert import *
+ from .modeling_modernbert import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/modernbert/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/modernbert/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..58d1046474064dc39466e7f6e7f018b1b65bc5cc
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/modernbert/__pycache__/__init__.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/modernbert/__pycache__/configuration_modernbert.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/modernbert/__pycache__/configuration_modernbert.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cf077a92042cfce8c6a8e7b29ba9489baeaaeca3
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/modernbert/__pycache__/configuration_modernbert.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/modernbert/__pycache__/modeling_modernbert.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/modernbert/__pycache__/modeling_modernbert.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..053ca8f814316bceb3b6c95f7c31d37068e7aa5f
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/modernbert/__pycache__/modeling_modernbert.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/modernbert/__pycache__/modular_modernbert.cpython-310.pyc b/vllm/lib/python3.10/site-packages/transformers/models/modernbert/__pycache__/modular_modernbert.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f04c599a22dc81193a563c71e5b862d7c4eb2687
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/transformers/models/modernbert/__pycache__/modular_modernbert.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/modernbert/configuration_modernbert.py b/vllm/lib/python3.10/site-packages/transformers/models/modernbert/configuration_modernbert.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc0295c25b55d7e5ac431b83c0d5c0b4fdf9762b
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/modernbert/configuration_modernbert.py
@@ -0,0 +1,218 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/modernbert/modular_modernbert.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_modernbert.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2024 Answer.AI, LightOn, and contributors, and the HuggingFace Inc. team. All rights reserved.
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Literal
+
+from ...configuration_utils import PretrainedConfig
+
+
+class ModernBertConfig(PretrainedConfig):
+ r"""
+ This is the configuration class to store the configuration of a [`ModernBertModel`]. It is used to instantiate an ModernBert
+ model according to the specified arguments, defining the model architecture. Instantiating a configuration with the
+ defaults will yield a similar configuration to that of the ModernBERT-base.
+ e.g. [answerdotai/ModernBERT-base](https://huggingface.co/answerdotai/ModernBERT-base)
+
+ Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+ documentation from [`PretrainedConfig`] for more information.
+
+ Args:
+ vocab_size (`int`, *optional*, defaults to 50368):
+ Vocabulary size of the ModernBert model. Defines the number of different tokens that can be represented by the
+ `inputs_ids` passed when calling [`ModernBertModel`]
+ hidden_size (`int`, *optional*, defaults to 768):
+ Dimension of the hidden representations.
+ intermediate_size (`int`, *optional*, defaults to 1152):
+ Dimension of the MLP representations.
+ num_hidden_layers (`int`, *optional*, defaults to 22):
+ Number of hidden layers in the Transformer decoder.
+ num_attention_heads (`int`, *optional*, defaults to 12):
+ Number of attention heads for each attention layer in the Transformer decoder.
+ hidden_activation (`str` or `function`, *optional*, defaults to `"gelu"`):
+ The non-linear activation function (function or string) in the decoder. Will default to `"gelu"`
+ if not specified.
+ max_position_embeddings (`int`, *optional*, defaults to 8192):
+ The maximum sequence length that this model might ever be used with.
+ initializer_range (`float`, *optional*, defaults to 0.02):
+ The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+ initializer_cutoff_factor (`float`, *optional*, defaults to 2.0):
+ The cutoff factor for the truncated_normal_initializer for initializing all weight matrices.
+ norm_eps (`float`, *optional*, defaults to 1e-05):
+ The epsilon used by the rms normalization layers.
+ norm_bias (`bool`, *optional*, defaults to `False`):
+ Whether to use bias in the normalization layers.
+ pad_token_id (`int`, *optional*, defaults to 50283):
+ Padding token id.
+ eos_token_id (`int`, *optional*, defaults to 50282):
+ End of stream token id.
+ bos_token_id (`int`, *optional*, defaults to 50281):
+ Beginning of stream token id.
+ cls_token_id (`int`, *optional*, defaults to 50281):
+ Classification token id.
+ sep_token_id (`int`, *optional*, defaults to 50282):
+ Separation token id.
+ global_rope_theta (`float`, *optional*, defaults to 160000.0):
+ The base period of the global RoPE embeddings.
+ attention_bias (`bool`, *optional*, defaults to `False`):
+ Whether to use a bias in the query, key, value and output projection layers during self-attention.
+ attention_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout ratio for the attention probabilities.
+ global_attn_every_n_layers (`int`, *optional*, defaults to 3):
+ The number of layers between global attention layers.
+ local_attention (`int`, *optional*, defaults to 128):
+ The window size for local attention.
+ local_rope_theta (`float`, *optional*, defaults to 10000.0):
+ The base period of the local RoPE embeddings.
+ embedding_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout ratio for the embeddings.
+ mlp_bias (`bool`, *optional*, defaults to `False`):
+ Whether to use bias in the MLP layers.
+ mlp_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout ratio for the MLP layers.
+ decoder_bias (`bool`, *optional*, defaults to `True`):
+ Whether to use bias in the decoder layers.
+ classifier_pooling (`str`, *optional*, defaults to `"cls"`):
+ The pooling method for the classifier. Should be either `"cls"` or `"mean"`. In local attention layers, the
+ CLS token doesn't attend to all tokens on long sequences.
+ classifier_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout ratio for the classifier.
+ classifier_bias (`bool`, *optional*, defaults to `False`):
+ Whether to use bias in the classifier.
+ classifier_activation (`str`, *optional*, defaults to `"gelu"`):
+ The activation function for the classifier.
+ deterministic_flash_attn (`bool`, *optional*, defaults to `False`):
+ Whether to use deterministic flash attention. If `False`, inference will be faster but not deterministic.
+ sparse_prediction (`bool`, *optional*, defaults to `False`):
+ Whether to use sparse prediction for the masked language model instead of returning the full dense logits.
+ sparse_pred_ignore_index (`int`, *optional*, defaults to -100):
+ The index to ignore for the sparse prediction.
+ reference_compile (`bool`, *optional*):
+ Whether to compile the layers of the model which were compiled during pretraining. If `None`, then parts of
+ the model will be compiled if 1) `triton` is installed, 2) the model is not on MPS, 3) the model is not
+ shared between devices, and 4) the model is not resized after initialization. If `True`, then the model may
+ be faster in some scenarios.
+ repad_logits_with_grad (`bool`, *optional*, defaults to `False`):
+ When True, ModernBertForMaskedLM keeps track of the logits' gradient when repadding for output. This only
+ applies when using Flash Attention 2 with passed labels. Otherwise output logits always have a gradient.
+
+ Examples:
+
+ ```python
+ >>> from transformers import ModernBertModel, ModernBertConfig
+
+ >>> # Initializing a ModernBert style configuration
+ >>> configuration = ModernBertConfig()
+
+ >>> # Initializing a model from the modernbert-base style configuration
+ >>> model = ModernBertModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "modernbert"
+ keys_to_ignore_at_inference = ["past_key_values"]
+
+ def __init__(
+ self,
+ vocab_size=50368,
+ hidden_size=768,
+ intermediate_size=1152,
+ num_hidden_layers=22,
+ num_attention_heads=12,
+ hidden_activation="gelu",
+ max_position_embeddings=8192,
+ initializer_range=0.02,
+ initializer_cutoff_factor=2.0,
+ norm_eps=1e-5,
+ norm_bias=False,
+ pad_token_id=50283,
+ eos_token_id=50282,
+ bos_token_id=50281,
+ cls_token_id=50281,
+ sep_token_id=50282,
+ global_rope_theta=160000.0,
+ attention_bias=False,
+ attention_dropout=0.0,
+ global_attn_every_n_layers=3,
+ local_attention=128,
+ local_rope_theta=10000.0,
+ embedding_dropout=0.0,
+ mlp_bias=False,
+ mlp_dropout=0.0,
+ decoder_bias=True,
+ classifier_pooling: Literal["cls", "mean"] = "cls",
+ classifier_dropout=0.0,
+ classifier_bias=False,
+ classifier_activation="gelu",
+ deterministic_flash_attn=False,
+ sparse_prediction=False,
+ sparse_pred_ignore_index=-100,
+ reference_compile=None,
+ repad_logits_with_grad=False,
+ **kwargs,
+ ):
+ super().__init__(
+ pad_token_id=pad_token_id,
+ bos_token_id=bos_token_id,
+ eos_token_id=eos_token_id,
+ cls_token_id=cls_token_id,
+ sep_token_id=sep_token_id,
+ **kwargs,
+ )
+ self.vocab_size = vocab_size
+ self.max_position_embeddings = max_position_embeddings
+ self.hidden_size = hidden_size
+ self.intermediate_size = intermediate_size
+ self.num_hidden_layers = num_hidden_layers
+ self.num_attention_heads = num_attention_heads
+ self.initializer_range = initializer_range
+ self.initializer_cutoff_factor = initializer_cutoff_factor
+ self.norm_eps = norm_eps
+ self.norm_bias = norm_bias
+ self.global_rope_theta = global_rope_theta
+ self.attention_bias = attention_bias
+ self.attention_dropout = attention_dropout
+ self.hidden_activation = hidden_activation
+ self.global_attn_every_n_layers = global_attn_every_n_layers
+ self.local_attention = local_attention
+ self.local_rope_theta = local_rope_theta
+ self.embedding_dropout = embedding_dropout
+ self.mlp_bias = mlp_bias
+ self.mlp_dropout = mlp_dropout
+ self.decoder_bias = decoder_bias
+ self.classifier_pooling = classifier_pooling
+ self.classifier_dropout = classifier_dropout
+ self.classifier_bias = classifier_bias
+ self.classifier_activation = classifier_activation
+ self.deterministic_flash_attn = deterministic_flash_attn
+ self.sparse_prediction = sparse_prediction
+ self.sparse_pred_ignore_index = sparse_pred_ignore_index
+ self.reference_compile = reference_compile
+ self.repad_logits_with_grad = repad_logits_with_grad
+
+ if self.classifier_pooling not in ["cls", "mean"]:
+ raise ValueError(
+ f'Invalid value for `classifier_pooling`, should be either "cls" or "mean", but is {self.classifier_pooling}.'
+ )
+
+
+__all__ = ["ModernBertConfig"]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/modernbert/modeling_modernbert.py b/vllm/lib/python3.10/site-packages/transformers/models/modernbert/modeling_modernbert.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d39041253d849551ecab00b943af65e31a77481
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/modernbert/modeling_modernbert.py
@@ -0,0 +1,1393 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/modernbert/modular_modernbert.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_modernbert.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2024 Answer.AI, LightOn, and contributors, and the HuggingFace Inc. team. All rights reserved.
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+from contextlib import nullcontext
+from typing import Dict, Optional, Tuple, Union
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+
+from ...activations import ACT2FN
+from ...modeling_attn_mask_utils import _prepare_4d_attention_mask
+from ...modeling_outputs import BaseModelOutput, MaskedLMOutput, SequenceClassifierOutput, TokenClassifierOutput
+from ...modeling_rope_utils import ROPE_INIT_FUNCTIONS
+from ...modeling_utils import PreTrainedModel
+from ...utils import (
+ add_code_sample_docstrings,
+ add_start_docstrings,
+ add_start_docstrings_to_model_forward,
+ is_flash_attn_2_available,
+ logging,
+)
+from ...utils.import_utils import is_triton_available
+from .configuration_modernbert import ModernBertConfig
+
+
+if is_flash_attn_2_available():
+ from flash_attn.flash_attn_interface import flash_attn_varlen_qkvpacked_func
+ from flash_attn.layers.rotary import RotaryEmbedding
+ from flash_attn.ops.triton.rotary import apply_rotary
+else:
+ RotaryEmbedding = object
+
+logger = logging.get_logger(__name__)
+
+_CHECKPOINT_FOR_DOC = "answerdotai/ModernBERT-base"
+_CONFIG_FOR_DOC = "ModernBertConfig"
+
+
+class ApplyRotaryEmbUnpad(torch.autograd.Function):
+ @staticmethod
+ def forward(
+ ctx,
+ qkv,
+ cos,
+ sin,
+ cu_seqlens: Optional[torch.Tensor] = None,
+ max_seqlen: Optional[int] = None,
+ ):
+ # (total_nnz, 3, nheads, headdim)
+ qkv = qkv.contiguous()
+ total_nnz, _three, _nheads, headdim = qkv.shape
+ # We need qkv to be contiguous so that when we reshape to combine (3, nheads) dimensions,
+ # we get the same tensor
+ # qk = rearrange(qkv[:, :2], "b_s t h d -> b_s (t h) d")
+ qk = qkv[:, :2].view(total_nnz, -1, headdim)
+ apply_rotary(
+ qk,
+ cos,
+ sin,
+ seqlen_offsets=0,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ interleaved=False,
+ inplace=True,
+ )
+
+ ctx.save_for_backward(cos, sin, cu_seqlens)
+ ctx.max_seqlen = max_seqlen
+ return qkv
+
+ @staticmethod
+ def backward(ctx, do):
+ cos, sin, cu_seqlens = ctx.saved_tensors
+ do = do.contiguous()
+ total_nnz, _three, _nheads, headdim = do.shape
+ # We need dqkv to be contiguous so that when we reshape to combine (3, nheads) dimensions,
+ # we get the same tensor
+ dqk = do[:, :2].view(total_nnz, -1, headdim)
+ apply_rotary(
+ dqk,
+ cos,
+ sin,
+ seqlen_offsets=0,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=ctx.max_seqlen,
+ interleaved=False,
+ inplace=True,
+ conjugate=True,
+ )
+
+ return do, None, None, None, None, None, None
+
+
+def apply_rotary_unpadded(
+ qkv,
+ cos,
+ sin,
+ cu_seqlens: Optional[torch.Tensor] = None,
+ max_seqlen: Optional[int] = None,
+):
+ """
+ Arguments:
+ qkv: (total_nnz, 3, nheads, headdim) - input tensor for packed QKV.
+ cos, sin: (seqlen_rotary, rotary_dim / 2)
+ interleaved: if True, rotate pairs of even and odd dimensions (GPT-J style) instead
+ of 1st half and 2nd half (GPT-NeoX style).
+ inplace: if True, apply rotary embedding in-place.
+ seqlen_offsets: (batch_size,) or int. Each sequence in x is shifted by this amount.
+ Most commonly used in inference when we have KV cache.
+ cu_seqlens: (batch + 1,) or None
+ max_seqlen: int
+ Return:
+ out: (total_nnz, dim)
+ rotary_dim must be <= headdim
+ Apply rotary embedding to the first rotary_dim of x.
+ """
+ return ApplyRotaryEmbUnpad.apply(qkv, cos, sin, cu_seqlens, max_seqlen)
+
+
+class ModernBertUnpaddedRotaryEmbedding(RotaryEmbedding):
+ """
+ The rotary position embeddings applied directly to unpadded sequences.
+ """
+
+ def __init__(
+ self,
+ dim: int,
+ base: float = 10000.0,
+ max_seqlen: Optional[int] = None,
+ device: Optional[torch.device] = None,
+ dtype: Optional[torch.dtype] = None,
+ ):
+ """
+ max_seqlen: if max_seqlen, device, and dtype are provided, we precompute the cos_sin_cache
+ up to max_seqlen. If the max_seqlen, device, or dtype during training/inference differ,
+ the cos_sin_cache wll be recomputed during the forward pass.
+ """
+ super().__init__(dim=dim, base=base, pos_idx_in_fp32=True, device=device, interleaved=False)
+ self.max_seqlen = max_seqlen
+
+ if max_seqlen is not None and device is not None and dtype is not None:
+ self._update_cos_sin_cache(max_seqlen, device=device, dtype=dtype)
+
+ def forward(
+ self,
+ qkv: torch.Tensor,
+ cu_seqlens: torch.Tensor,
+ max_seqlen: Optional[int] = None,
+ ) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:
+ """
+ Apply rotary embedding *inplace* to qkv.
+ qkv: (total_nnz, 3, nheads, headdim)
+ cu_seqlens: (batch + 1,) cumulative sequence lengths
+ max_seqlen: int max seq length in the batch
+ """
+ if max_seqlen is not None:
+ self._update_cos_sin_cache(max_seqlen, device=qkv.device, dtype=qkv.dtype)
+
+ qkv = apply_rotary_unpadded(
+ qkv,
+ self._cos_cached,
+ self._sin_cached,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ )
+
+ return qkv
+
+ def extra_repr(self) -> str:
+ return f"dim={self.dim}, base={self.base}, scale_base={self.scale_base}"
+
+
+class ModernBertEmbeddings(nn.Module):
+ """
+ Same as BertEmbeddings with a tiny tweak for positional embeddings indexing.
+ """
+
+ def __init__(self, config: ModernBertConfig):
+ super().__init__()
+ self.config = config
+ self.tok_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
+ self.norm = nn.LayerNorm(config.hidden_size, eps=config.norm_eps, bias=config.norm_bias)
+ self.drop = nn.Dropout(config.embedding_dropout)
+
+ @torch.compile(dynamic=True)
+ def compiled_embeddings(self, input_ids: torch.LongTensor) -> torch.Tensor:
+ return self.drop(self.norm(self.tok_embeddings(input_ids)))
+
+ def forward(
+ self, input_ids: torch.LongTensor = None, inputs_embeds: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ if inputs_embeds is not None:
+ hidden_states = self.drop(self.norm(inputs_embeds))
+ else:
+ hidden_states = (
+ self.compiled_embeddings(input_ids)
+ if self.config.reference_compile
+ else self.drop(self.norm(self.tok_embeddings(input_ids)))
+ )
+ return hidden_states
+
+
+class ModernBertMLP(nn.Module):
+ """Applies the GLU at the end of each ModernBERT layer.
+
+ Compared to the default BERT architecture, this block replaces :class:`~transformers.model.bert.modeling_bert.BertIntermediate`
+ and :class:`~transformers.model.bert.modeling_bert.SelfOutput` with a single module that has similar functionality.
+ """
+
+ def __init__(self, config: ModernBertConfig):
+ super().__init__()
+ self.config = config
+ self.Wi = nn.Linear(config.hidden_size, int(config.intermediate_size) * 2, bias=config.mlp_bias)
+ self.act = ACT2FN[config.hidden_activation]
+ self.drop = nn.Dropout(config.mlp_dropout)
+ self.Wo = nn.Linear(config.intermediate_size, config.hidden_size, bias=config.mlp_bias)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ input, gate = self.Wi(hidden_states).chunk(2, dim=-1)
+ return self.Wo(self.drop(self.act(input) * gate))
+
+
+class ModernBertRotaryEmbedding(nn.Module):
+ def __init__(self, config: ModernBertConfig, dim: int, base: float, device: Optional[torch.device] = None):
+ super().__init__()
+ # BC: "rope_type" was originally "type"
+ if hasattr(config, "rope_scaling") and config.rope_scaling is not None:
+ self.rope_type = config.rope_scaling.get("rope_type", config.rope_scaling.get("type"))
+ else:
+ self.rope_type = "default"
+ self.max_seq_len_cached = config.max_position_embeddings
+ self.original_max_seq_len = config.max_position_embeddings
+
+ self.config = config
+ self.rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type]
+ inv_freq, self.attention_scaling = self.rope_init_fn(None, device, dim=dim, base=base)
+ self.register_buffer("inv_freq", inv_freq, persistent=False)
+ self.original_inv_freq = self.inv_freq
+
+ def _dynamic_frequency_update(self, position_ids, device):
+ """
+ dynamic RoPE layers should recompute `inv_freq` in the following situations:
+ 1 - growing beyond the cached sequence length (allow scaling)
+ 2 - the current sequence length is in the original scale (avoid losing precision with small sequences)
+ """
+ seq_len = torch.max(position_ids) + 1
+ if seq_len > self.max_seq_len_cached: # growth
+ inv_freq, self.attention_scaling = self.rope_init_fn(self.config, device, seq_len=seq_len)
+ self.register_buffer("inv_freq", inv_freq, persistent=False) # TODO joao: may break with compilation
+ self.max_seq_len_cached = seq_len
+
+ if seq_len < self.original_max_seq_len and self.max_seq_len_cached > self.original_max_seq_len: # reset
+ # This .to() is needed if the model has been moved to a device after being initialized (because
+ # the buffer is automatically moved, but not the original copy)
+ self.original_inv_freq = self.original_inv_freq.to(device)
+ self.register_buffer("inv_freq", self.original_inv_freq, persistent=False)
+ self.max_seq_len_cached = self.original_max_seq_len
+
+ @torch.no_grad()
+ def forward(self, x, position_ids):
+ if "dynamic" in self.rope_type:
+ self._dynamic_frequency_update(position_ids, device=x.device)
+
+ # Core RoPE block
+ inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1)
+ position_ids_expanded = position_ids[:, None, :].float()
+ # Force float32 (see https://github.com/huggingface/transformers/pull/29285)
+ device_type = x.device.type
+ device_type = device_type if isinstance(device_type, str) and device_type != "mps" else "cpu"
+ with torch.autocast(device_type=device_type, enabled=False):
+ freqs = (inv_freq_expanded.float().to(x.device) @ position_ids_expanded.float()).transpose(1, 2)
+ emb = torch.cat((freqs, freqs), dim=-1)
+ cos = emb.cos()
+ sin = emb.sin()
+
+ # Advanced RoPE types (e.g. yarn) apply a post-processing scaling factor, equivalent to scaling attention
+ cos = cos * self.attention_scaling
+ sin = sin * self.attention_scaling
+
+ return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype)
+
+
+def rotate_half(x):
+ """Rotates half the hidden dims of the input."""
+ x1 = x[..., : x.shape[-1] // 2]
+ x2 = x[..., x.shape[-1] // 2 :]
+ return torch.cat((-x2, x1), dim=-1)
+
+
+def apply_rotary_pos_emb(q, k, cos, sin, position_ids=None, unsqueeze_dim=1):
+ """Applies Rotary Position Embedding to the query and key tensors.
+
+ Args:
+ q (`torch.Tensor`): The query tensor.
+ k (`torch.Tensor`): The key tensor.
+ cos (`torch.Tensor`): The cosine part of the rotary embedding.
+ sin (`torch.Tensor`): The sine part of the rotary embedding.
+ position_ids (`torch.Tensor`, *optional*):
+ Deprecated and unused.
+ unsqueeze_dim (`int`, *optional*, defaults to 1):
+ The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and
+ sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note
+ that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and
+ k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes
+ cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have
+ the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2.
+ Returns:
+ `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding.
+ """
+ cos = cos.unsqueeze(unsqueeze_dim)
+ sin = sin.unsqueeze(unsqueeze_dim)
+ q_embed = (q * cos) + (rotate_half(q) * sin)
+ k_embed = (k * cos) + (rotate_half(k) * sin)
+ return q_embed, k_embed
+
+
+def eager_attention_forward(
+ module: "ModernBertAttention",
+ qkv: torch.Tensor,
+ attention_mask: torch.Tensor,
+ sliding_window_mask: torch.Tensor,
+ position_ids: Optional[torch.LongTensor],
+ local_attention: Tuple[int, int],
+ bs: int,
+ dim: int,
+ output_attentions: Optional[bool] = False,
+ **_kwargs,
+) -> Union[Tuple[torch.Tensor, torch.Tensor], Tuple[torch.Tensor]]:
+ # qkv: [batch_size, seqlen, 3, nheads, headdim]
+ cos, sin = module.rotary_emb(qkv, position_ids=position_ids)
+ query, key, value = qkv.transpose(3, 1).unbind(dim=2)
+ # query, key, value: [batch_size, heads, seq_len, head_dim]
+ query, key = apply_rotary_pos_emb(query, key, cos, sin)
+
+ scale = module.head_dim**-0.5
+ attn_weights = torch.matmul(query, key.transpose(2, 3)) * scale
+
+ if local_attention != (-1, -1):
+ attention_mask = sliding_window_mask
+
+ attn_weights = attn_weights + attention_mask
+
+ # upcast attention to fp32
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)
+ attn_weights = nn.functional.dropout(attn_weights, p=module.attention_dropout, training=module.training)
+ attn_output = torch.matmul(attn_weights, value)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+ attn_output = attn_output.view(bs, -1, dim)
+ if output_attentions:
+ return (attn_output, attn_weights)
+ return (attn_output,)
+
+
+def flash_attention_forward(
+ module: "ModernBertAttention",
+ qkv: torch.Tensor,
+ rotary_emb: ModernBertUnpaddedRotaryEmbedding,
+ cu_seqlens: torch.Tensor,
+ max_seqlen: int,
+ local_attention: Tuple[int, int],
+ bs: int,
+ dim: int,
+ target_dtype: torch.dtype = torch.bfloat16,
+ **_kwargs,
+) -> Tuple[torch.Tensor]:
+ # (total_seqlen, 3, nheads, headdim)
+ qkv = rotary_emb(qkv, cu_seqlens=cu_seqlens, max_seqlen=max_seqlen)
+
+ convert_dtype = qkv.dtype not in (torch.float16, torch.bfloat16)
+ if convert_dtype:
+ # FA2 implementation only supports fp16 and bf16. If FA2 is supported,
+ # bfloat16 must be supported as of FA2 2.5.7. (Turing GPUs not supported)
+ orig_dtype = qkv.dtype
+ qkv = qkv.to(target_dtype)
+
+ attn = flash_attn_varlen_qkvpacked_func(
+ qkv,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ dropout_p=module.attention_dropout if module.training else 0.0,
+ deterministic=module.deterministic_flash_attn,
+ window_size=local_attention,
+ )
+ attn = attn.to(orig_dtype) # type: ignore
+ else:
+ attn = flash_attn_varlen_qkvpacked_func(
+ qkv,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ dropout_p=module.attention_dropout if module.training else 0.0,
+ deterministic=module.deterministic_flash_attn,
+ window_size=local_attention,
+ )
+ return (attn.view(bs, dim),)
+
+
+def sdpa_attention_forward(
+ module: "ModernBertAttention",
+ qkv: torch.Tensor,
+ attention_mask: torch.Tensor,
+ sliding_window_mask: torch.Tensor,
+ position_ids: Optional[torch.LongTensor],
+ local_attention: Tuple[int, int],
+ bs: int,
+ dim: int,
+ **_kwargs,
+) -> Tuple[torch.Tensor]:
+ # qkv: [batch_size, seqlen, 3, nheads, headdim]
+ cos, sin = module.rotary_emb(qkv, position_ids=position_ids)
+ query, key, value = qkv.transpose(3, 1).unbind(dim=2)
+ # query, key, value: [batch_size, heads, seq_len, head_dim]
+ query, key = apply_rotary_pos_emb(query, key, cos, sin)
+
+ if local_attention != (-1, -1):
+ attention_mask = sliding_window_mask
+
+ attn_output = (
+ F.scaled_dot_product_attention(
+ query,
+ key,
+ value,
+ dropout_p=module.attention_dropout if module.training else 0.0,
+ attn_mask=attention_mask,
+ )
+ .transpose(1, 2)
+ .contiguous()
+ )
+ attn_output = attn_output.view(bs, -1, dim)
+ return (attn_output,)
+
+
+MODERNBERT_ATTENTION_FUNCTION = {
+ "flash_attention_2": flash_attention_forward,
+ "eager": eager_attention_forward,
+ "sdpa": sdpa_attention_forward,
+}
+
+
+class ModernBertAttention(nn.Module):
+ """Performs multi-headed self attention on a batch of unpadded sequences.
+
+ If Flash Attention 2 is installed, this module uses Flash Attention to improve throughput.
+ If Flash Attention 2 is not installed, the implementation will use PyTorch's SDPA kernel,
+ which requires padding and unpadding inputs, adding some overhead.
+
+ See `forward` method for additional details.
+ """
+
+ def __init__(self, config: ModernBertConfig, layer_id: Optional[int] = None):
+ super().__init__()
+ self.config = config
+ self.layer_id = layer_id
+
+ if config.hidden_size % config.num_attention_heads != 0:
+ raise ValueError(
+ f"The hidden size ({config.hidden_size}) is not a multiple of the number of attention heads ({config.num_attention_heads})"
+ )
+
+ self.attention_dropout = config.attention_dropout
+ self.deterministic_flash_attn = config.deterministic_flash_attn
+ self.num_heads = config.num_attention_heads
+ self.head_dim = config.hidden_size // config.num_attention_heads
+ self.all_head_size = self.head_dim * self.num_heads
+ self.Wqkv = nn.Linear(config.hidden_size, 3 * self.all_head_size, bias=config.attention_bias)
+
+ if layer_id % config.global_attn_every_n_layers != 0:
+ self.local_attention = (config.local_attention // 2, config.local_attention // 2)
+ else:
+ self.local_attention = (-1, -1)
+
+ rope_theta = config.global_rope_theta
+ max_position_embeddings = config.max_position_embeddings
+ if self.local_attention != (-1, -1):
+ if config.local_rope_theta is not None:
+ rope_theta = config.local_rope_theta
+ max_position_embeddings = config.local_attention
+
+ if config._attn_implementation == "flash_attention_2":
+ self.rotary_emb = ModernBertUnpaddedRotaryEmbedding(
+ dim=self.head_dim, max_seqlen=max_position_embeddings, base=rope_theta
+ )
+ else:
+ self.rotary_emb = ModernBertRotaryEmbedding(config=config, dim=self.head_dim, base=rope_theta)
+
+ self.Wo = nn.Linear(config.hidden_size, config.hidden_size, bias=config.attention_bias)
+ self.out_drop = nn.Dropout(config.attention_dropout) if config.attention_dropout > 0.0 else nn.Identity()
+ self.pruned_heads = set()
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ output_attentions: Optional[bool] = False,
+ **kwargs,
+ ) -> torch.Tensor:
+ qkv = self.Wqkv(hidden_states)
+
+ bs = hidden_states.shape[0]
+ if self.config._attn_implementation == "flash_attention_2":
+ qkv = qkv.view(-1, 3, self.num_heads, self.head_dim)
+ else:
+ qkv = qkv.view(bs, -1, 3, self.num_heads, self.head_dim)
+
+ attn_outputs = MODERNBERT_ATTENTION_FUNCTION[self.config._attn_implementation](
+ self,
+ qkv=qkv,
+ rotary_emb=self.rotary_emb,
+ local_attention=self.local_attention,
+ bs=bs,
+ dim=self.all_head_size,
+ output_attentions=output_attentions,
+ **kwargs,
+ )
+ hidden_states = attn_outputs[0]
+ hidden_states = self.out_drop(self.Wo(hidden_states))
+
+ return (hidden_states,) + attn_outputs[1:] # add attentions if outputted
+
+
+class ModernBertEncoderLayer(nn.Module):
+ def __init__(self, config: ModernBertConfig, layer_id: Optional[int] = None):
+ super().__init__()
+ self.config = config
+ if layer_id == 0:
+ self.attn_norm = nn.Identity()
+ else:
+ self.attn_norm = nn.LayerNorm(config.hidden_size, eps=config.norm_eps, bias=config.norm_bias)
+ self.attn = ModernBertAttention(config=config, layer_id=layer_id)
+ self.mlp_norm = nn.LayerNorm(config.hidden_size, eps=config.norm_eps, bias=config.norm_bias)
+ self.mlp = ModernBertMLP(config)
+
+ @torch.compile(dynamic=True)
+ def compiled_mlp(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ return self.mlp(self.mlp_norm(hidden_states))
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: Optional[torch.Tensor] = None,
+ sliding_window_mask: Optional[torch.Tensor] = None,
+ position_ids: Optional[torch.LongTensor] = None,
+ cu_seqlens: Optional[torch.Tensor] = None,
+ max_seqlen: Optional[int] = None,
+ output_attentions: Optional[bool] = False,
+ ) -> torch.Tensor:
+ attn_outputs = self.attn(
+ self.attn_norm(hidden_states),
+ attention_mask=attention_mask,
+ sliding_window_mask=sliding_window_mask,
+ position_ids=position_ids,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ output_attentions=output_attentions,
+ )
+ hidden_states = hidden_states + attn_outputs[0]
+ mlp_output = (
+ self.compiled_mlp(hidden_states)
+ if self.config.reference_compile
+ else self.mlp(self.mlp_norm(hidden_states))
+ )
+ hidden_states = hidden_states + mlp_output
+
+ return (hidden_states,) + attn_outputs[1:] # add attentions if outputted
+
+
+MODERNBERT_START_DOCSTRING = r"""
+ This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
+ library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
+ etc.)
+
+ This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
+ Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
+ and behavior.
+
+ Parameters:
+ config ([`ModernBertConfig`]):
+ Model configuration class with all the parameters of the model. Initializing with a config file does not
+ load the weights associated with the model, only the configuration. Check out the
+ [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+"""
+
+
+@add_start_docstrings(
+ "The bare ModernBert Model outputting raw hidden-states without any specific head on top.",
+ MODERNBERT_START_DOCSTRING,
+)
+class ModernBertPreTrainedModel(PreTrainedModel):
+ config_class = ModernBertConfig
+ base_model_prefix = "model"
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["ModernBertEmbeddings", "ModernBertEncoderLayer"]
+ _supports_flash_attn_2 = True
+ _supports_sdpa = True
+ _supports_flex_attn = False
+
+ def _init_weights(self, module: nn.Module):
+ cutoff_factor = self.config.initializer_cutoff_factor
+ if cutoff_factor is None:
+ cutoff_factor = 3
+
+ def init_weight(module: nn.Module, std: float):
+ nn.init.trunc_normal_(
+ module.weight,
+ mean=0.0,
+ std=std,
+ a=-cutoff_factor * std,
+ b=cutoff_factor * std,
+ )
+
+ if isinstance(module, nn.Linear):
+ if module.bias is not None:
+ nn.init.zeros_(module.bias)
+
+ stds = {
+ "in": self.config.initializer_range,
+ "out": self.config.initializer_range / math.sqrt(2.0 * self.config.num_hidden_layers),
+ "embedding": self.config.initializer_range,
+ "final_out": self.config.hidden_size**-0.5,
+ }
+
+ if isinstance(module, ModernBertEmbeddings):
+ init_weight(module.tok_embeddings, stds["embedding"])
+ elif isinstance(module, ModernBertMLP):
+ init_weight(module.Wi, stds["in"])
+ init_weight(module.Wo, stds["out"])
+ elif isinstance(module, ModernBertAttention):
+ init_weight(module.Wqkv, stds["in"])
+ init_weight(module.Wo, stds["out"])
+ elif isinstance(module, ModernBertPredictionHead):
+ init_weight(module.dense, stds["out"])
+ elif isinstance(module, ModernBertForMaskedLM):
+ init_weight(module.decoder, stds["out"])
+ elif isinstance(module, (ModernBertForSequenceClassification, ModernBertForTokenClassification)):
+ init_weight(module.classifier, stds["final_out"])
+
+ @classmethod
+ def _autoset_attn_implementation(
+ cls,
+ config,
+ use_flash_attention_2: bool = False,
+ torch_dtype: Optional[torch.dtype] = None,
+ device_map: Optional[Union[str, Dict[str, int]]] = None,
+ check_device_map: bool = True,
+ ):
+ # If the user didn't specify anything, try to use flash_attention_2 if available.
+ # Otherwise we fall back to the default SDPA -> Eager from the super() method.
+ # ModernBert's FA2 implementation correctly handles non-fp16/bf16 dtypes, we don't
+ # need the FA2 warning for non-fp16/bf16 dtypes so we set fp16 for the FA2 check.
+ if config._attn_implementation_internal is None:
+ config._attn_implementation_internal = "flash_attention_2"
+ try:
+ return cls._check_and_enable_flash_attn_2(
+ config,
+ torch_dtype=torch.float16,
+ device_map=device_map,
+ hard_check_only=False,
+ check_device_map=check_device_map,
+ )
+ except (ValueError, ImportError):
+ config._attn_implementation_internal = None
+ return super()._autoset_attn_implementation(
+ config,
+ use_flash_attention_2=use_flash_attention_2,
+ torch_dtype=torch.float16,
+ device_map=device_map,
+ check_device_map=check_device_map,
+ )
+
+ def _maybe_set_compile(self):
+ if self.config.reference_compile is False:
+ return
+
+ if hasattr(self, "hf_device_map") and len(self.hf_device_map) > 1:
+ if self.config.reference_compile:
+ logger.warning_once(
+ "If `accelerate` split the model across devices, `torch.compile` will not work. "
+ "Falling back to non-compiled mode."
+ )
+ self.config.reference_compile = False
+
+ if self.device.type == "mps":
+ if self.config.reference_compile:
+ logger.warning_once(
+ "Compiling the model with `torch.compile` and using a `torch.mps` device is not supported. "
+ "Falling back to non-compiled mode."
+ )
+ self.config.reference_compile = False
+
+ if self.device.type == "cpu":
+ if self.config.reference_compile:
+ logger.warning_once(
+ "Compiling the model with `torch.compile` and using a `torch.cpu` device is not supported. "
+ "Falling back to non-compiled mode."
+ )
+ self.config.reference_compile = False
+
+ if self.config.reference_compile is None:
+ self.config.reference_compile = is_triton_available()
+
+ def resize_token_embeddings(self, *args, **kwargs):
+ model_embeds = super().resize_token_embeddings(*args, **kwargs)
+
+ if self.config.reference_compile in {True, None}:
+ if self.config.reference_compile:
+ logger.warning_once(
+ "Resizing token embeddings with `torch.compile` is not supported. Falling back to non-compiled mode."
+ )
+ self.config.reference_compile = False
+
+ return model_embeds
+
+
+def _unpad_modernbert_input(
+ inputs: torch.Tensor,
+ attention_mask: torch.Tensor,
+ position_ids: Optional[torch.Tensor] = None,
+ labels: Optional[torch.Tensor] = None,
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, int, Optional[torch.Tensor], Optional[torch.Tensor]]:
+ """
+ Remove padding from input sequences.
+
+ Args:
+ inputs: (batch, seqlen, ...) or (batch, seqlen)
+ attention_mask: (batch, seqlen), bool / int, 1 means valid and 0 means not valid.
+ position_ids: (batch, seqlen), int, position ids
+ labels: (batch, seqlen), int, labels
+
+ Returns:
+ unpadded_inputs: (total_nnz, ...), where total_nnz = number of tokens selected in attention_mask.
+ indices: (total_nnz)
+ cu_seqlens: (batch + 1), the cumulative sequence lengths
+ max_seqlen_in_batch: int
+ unpadded_position_ids: (total_nnz) or None
+ unpadded_labels: (total_nnz) or None
+ """
+ seqlens_in_batch = attention_mask.sum(dim=-1, dtype=torch.int32)
+ indices = torch.nonzero(attention_mask.flatten(), as_tuple=False).flatten()
+ max_seqlen_in_batch = int(seqlens_in_batch.max().item())
+ cu_seqlens = torch.nn.functional.pad(torch.cumsum(seqlens_in_batch, dim=0, dtype=torch.int32), (1, 0))
+
+ if inputs.dim() == 2:
+ unpadded_inputs = inputs.flatten()[indices]
+ else:
+ batch, seqlen, *rest = inputs.shape
+ shape = batch * seqlen
+ unpadded_inputs = inputs.view(shape, *rest)[indices]
+
+ unpadded_position_ids = position_ids.flatten()[indices] if position_ids is not None else None
+ unpadded_labels = labels.flatten()[indices] if labels is not None else None
+
+ return unpadded_inputs, indices, cu_seqlens, max_seqlen_in_batch, unpadded_position_ids, unpadded_labels
+
+
+def _pad_modernbert_output(
+ inputs: torch.Tensor,
+ indices: torch.Tensor,
+ batch: int,
+ seqlen: int,
+) -> torch.Tensor:
+ """
+ Add padding to sequences.
+
+ Args:
+ inputs: (total_nnz, ...) or (total_nnz,), where total_nnz = number of tokens selected in attention_mask.
+ indices: (total_nnz)
+ batch: int, batch size
+ seqlen: int, max sequence length
+
+ Returns:
+ padded_inputs: (batch, seqlen, ...) or (batch, seqlen)
+ """
+ if inputs.dim() == 1:
+ output = torch.zeros(batch * seqlen, dtype=inputs.dtype, device=inputs.device)
+ output[indices] = inputs
+ padded_inputs = output.view(batch, seqlen)
+ else:
+ _, *rest = inputs.shape
+ output = torch.zeros(batch * seqlen, *rest, dtype=inputs.dtype, device=inputs.device)
+ output[indices] = inputs
+ padded_inputs = output.view(batch, seqlen, *rest)
+
+ return padded_inputs
+
+
+MODERNBERT_INPUTS_DOCSTRING = r"""
+ Args:
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary. With Flash Attention 2.0, padding will be ignored
+ by default should you provide it.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are input IDs?](../glossary#input-ids)
+ attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+
+ - 1 for tokens that are **not masked**,
+ - 0 for tokens that are **masked**.
+
+ [What are attention masks?](../glossary#attention-mask)
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ If you want to change padding behavior, you should read [`modeling_opt._prepare_decoder_attention_mask`]
+ and modify to your needs. See diagram 1 in [the paper](https://arxiv.org/abs/1910.13461) for more
+ information on the default strategy.
+
+ - 1 indicates the head is **not masked**,
+ - 0 indicates the head is **masked**.
+ sliding_window_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing attention on padding or far-away tokens. In ModernBert, only every few layers
+ perform global attention, while the rest perform local attention. This mask is used to avoid attending to
+ far-away tokens in the local attention layers when not using Flash Attention.
+ position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.n_positions - 1]`.
+
+ [What are position IDs?](../glossary#position-ids)
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+ Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
+ is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
+ model's internal embedding lookup matrix.
+ indices (`torch.Tensor` of shape `(total_unpadded_tokens,)`, *optional*):
+ Indices of the non-padding tokens in the input sequence. Used for unpadding the output.
+ cu_seqlens (`torch.Tensor` of shape `(batch + 1,)`, *optional*):
+ Cumulative sequence lengths of the input sequences. Used to index the unpadded tensors.
+ max_seqlen (`int`, *optional*):
+ Maximum sequence length in the batch excluding padding tokens. Used to unpad input_ids and pad output tensors.
+ batch_size (`int`, *optional*):
+ Batch size of the input sequences. Used to pad the output tensors.
+ seq_len (`int`, *optional*):
+ Sequence length of the input sequences including padding tokens. Used to pad the output tensors.
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
+ tensors for more detail.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+ more detail.
+ return_dict (`bool`, *optional*):
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+"""
+
+
+@add_start_docstrings(
+ "The bare ModernBert Model outputting raw hidden-states without any specific head on top.",
+ MODERNBERT_START_DOCSTRING,
+)
+class ModernBertModel(ModernBertPreTrainedModel):
+ def __init__(self, config: ModernBertConfig):
+ super().__init__(config)
+ self.config = config
+ self.embeddings = ModernBertEmbeddings(config)
+ self.layers = nn.ModuleList(
+ [ModernBertEncoderLayer(config, layer_id) for layer_id in range(config.num_hidden_layers)]
+ )
+ self.final_norm = nn.LayerNorm(config.hidden_size, eps=config.norm_eps, bias=config.norm_bias)
+ self.gradient_checkpointing = False
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.embeddings.tok_embeddings
+
+ def set_input_embeddings(self, value):
+ self.embeddings.tok_embeddings = value
+
+ @add_start_docstrings_to_model_forward(MODERNBERT_INPUTS_DOCSTRING)
+ @add_code_sample_docstrings(
+ checkpoint=_CHECKPOINT_FOR_DOC,
+ output_type=BaseModelOutput,
+ config_class=_CONFIG_FOR_DOC,
+ )
+ def forward(
+ self,
+ input_ids: Optional[torch.LongTensor] = None,
+ attention_mask: Optional[torch.Tensor] = None,
+ sliding_window_mask: Optional[torch.Tensor] = None,
+ position_ids: Optional[torch.LongTensor] = None,
+ inputs_embeds: Optional[torch.Tensor] = None,
+ indices: Optional[torch.Tensor] = None,
+ cu_seqlens: Optional[torch.Tensor] = None,
+ max_seqlen: Optional[int] = None,
+ batch_size: Optional[int] = None,
+ seq_len: Optional[int] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ ) -> Union[Tuple[torch.Tensor, ...], BaseModelOutput]:
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+ all_hidden_states = () if output_hidden_states else None
+ all_self_attentions = () if output_attentions else None
+
+ self._maybe_set_compile()
+
+ if input_ids is not None:
+ self.warn_if_padding_and_no_attention_mask(input_ids, attention_mask)
+
+ if batch_size is None and seq_len is None:
+ if inputs_embeds is not None:
+ batch_size, seq_len = inputs_embeds.shape[:2]
+ else:
+ batch_size, seq_len = input_ids.shape[:2]
+ device = input_ids.device if input_ids is not None else inputs_embeds.device
+
+ if attention_mask is None:
+ attention_mask = torch.ones((batch_size, seq_len), device=device, dtype=torch.bool)
+
+ repad = False
+ if self.config._attn_implementation == "flash_attention_2":
+ if indices is None and cu_seqlens is None and max_seqlen is None:
+ repad = True
+ if inputs_embeds is None:
+ with torch.no_grad():
+ input_ids, indices, cu_seqlens, max_seqlen, *_ = _unpad_modernbert_input(
+ inputs=input_ids, attention_mask=attention_mask
+ )
+ else:
+ inputs_embeds, indices, cu_seqlens, max_seqlen, *_ = _unpad_modernbert_input(
+ inputs=inputs_embeds, attention_mask=attention_mask
+ )
+ else:
+ if position_ids is None:
+ position_ids = torch.arange(seq_len, device=device).unsqueeze(0)
+
+ attention_mask, sliding_window_mask = self._update_attention_mask(
+ attention_mask, output_attentions=output_attentions
+ )
+
+ hidden_states = self.embeddings(input_ids=input_ids, inputs_embeds=inputs_embeds)
+
+ for encoder_layer in self.layers:
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ if self.gradient_checkpointing and self.training:
+ layer_outputs = self._gradient_checkpointing_func(
+ encoder_layer.__call__,
+ hidden_states,
+ attention_mask,
+ sliding_window_mask,
+ position_ids,
+ cu_seqlens,
+ max_seqlen,
+ output_attentions,
+ )
+ else:
+ layer_outputs = encoder_layer(
+ hidden_states,
+ attention_mask=attention_mask,
+ sliding_window_mask=sliding_window_mask,
+ position_ids=position_ids,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ output_attentions=output_attentions,
+ )
+ hidden_states = layer_outputs[0]
+ if output_attentions and len(layer_outputs) > 1:
+ all_self_attentions = all_self_attentions + (layer_outputs[1],)
+
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ hidden_states = self.final_norm(hidden_states)
+
+ if repad:
+ hidden_states = _pad_modernbert_output(
+ inputs=hidden_states, indices=indices, batch=batch_size, seqlen=seq_len
+ )
+ if all_hidden_states is not None:
+ all_hidden_states = tuple(
+ _pad_modernbert_output(inputs=hs, indices=indices, batch=batch_size, seqlen=seq_len)
+ for hs in all_hidden_states
+ )
+
+ if not return_dict:
+ return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None)
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ hidden_states=all_hidden_states,
+ attentions=all_self_attentions,
+ )
+
+ def _update_attention_mask(self, attention_mask: torch.Tensor, output_attentions: bool) -> torch.Tensor:
+ if output_attentions:
+ if self.config._attn_implementation == "sdpa":
+ logger.warning_once(
+ "Outputting attentions is only supported with the 'eager' attention implementation, "
+ 'not with "sdpa". Falling back to `attn_implementation="eager"`.'
+ )
+ self.config._attn_implementation = "eager"
+ elif self.config._attn_implementation != "eager":
+ logger.warning_once(
+ "Outputting attentions is only supported with the eager attention implementation, "
+ f'not with {self.config._attn_implementation}. Consider setting `attn_implementation="eager"`.'
+ " Setting `output_attentions=False`."
+ )
+
+ global_attention_mask = _prepare_4d_attention_mask(attention_mask, self.dtype)
+
+ # Create position indices
+ rows = torch.arange(global_attention_mask.shape[2]).unsqueeze(0)
+ # Calculate distance between positions
+ distance = torch.abs(rows - rows.T)
+
+ # Create sliding window mask (1 for positions within window, 0 outside)
+ window_mask = (
+ (distance <= self.config.local_attention // 2).unsqueeze(0).unsqueeze(0).to(attention_mask.device)
+ )
+ # Combine with existing mask
+ sliding_window_mask = global_attention_mask.masked_fill(window_mask.logical_not(), torch.finfo(self.dtype).min)
+
+ return global_attention_mask, sliding_window_mask
+
+
+class ModernBertPredictionHead(nn.Module):
+ def __init__(self, config: ModernBertConfig):
+ super().__init__()
+ self.config = config
+ self.dense = nn.Linear(config.hidden_size, config.hidden_size, config.classifier_bias)
+ self.act = ACT2FN[config.classifier_activation]
+ self.norm = nn.LayerNorm(config.hidden_size, eps=config.norm_eps, bias=config.norm_bias)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ return self.norm(self.act(self.dense(hidden_states)))
+
+
+@add_start_docstrings(
+ "The ModernBert Model with a decoder head on top that is used for masked language modeling.",
+ MODERNBERT_START_DOCSTRING,
+)
+class ModernBertForMaskedLM(ModernBertPreTrainedModel):
+ _tied_weights_keys = ["decoder.weight"]
+
+ def __init__(self, config: ModernBertConfig):
+ super().__init__(config)
+ self.config = config
+ self.model = ModernBertModel(config)
+ self.head = ModernBertPredictionHead(config)
+ self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=config.decoder_bias)
+
+ self.sparse_prediction = self.config.sparse_prediction
+ self.sparse_pred_ignore_index = self.config.sparse_pred_ignore_index
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_output_embeddings(self):
+ return self.decoder
+
+ def set_output_embeddings(self, new_embeddings: nn.Linear):
+ self.decoder = new_embeddings
+
+ @torch.compile(dynamic=True)
+ def compiled_head(self, output: torch.Tensor) -> torch.Tensor:
+ return self.decoder(self.head(output))
+
+ @add_start_docstrings_to_model_forward(MODERNBERT_INPUTS_DOCSTRING)
+ @add_code_sample_docstrings(
+ checkpoint=_CHECKPOINT_FOR_DOC,
+ output_type=MaskedLMOutput,
+ config_class=_CONFIG_FOR_DOC,
+ )
+ def forward(
+ self,
+ input_ids: Optional[torch.LongTensor] = None,
+ attention_mask: Optional[torch.Tensor] = None,
+ sliding_window_mask: Optional[torch.Tensor] = None,
+ position_ids: Optional[torch.Tensor] = None,
+ inputs_embeds: Optional[torch.Tensor] = None,
+ labels: Optional[torch.Tensor] = None,
+ indices: Optional[torch.Tensor] = None,
+ cu_seqlens: Optional[torch.Tensor] = None,
+ max_seqlen: Optional[int] = None,
+ batch_size: Optional[int] = None,
+ seq_len: Optional[int] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ **kwargs,
+ ) -> Union[Tuple[torch.Tensor], MaskedLMOutput]:
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+ self._maybe_set_compile()
+
+ if self.config._attn_implementation == "flash_attention_2":
+ if indices is None and cu_seqlens is None and max_seqlen is None:
+ if batch_size is None and seq_len is None:
+ if inputs_embeds is not None:
+ batch_size, seq_len = inputs_embeds.shape[:2]
+ else:
+ batch_size, seq_len = input_ids.shape[:2]
+ device = input_ids.device if input_ids is not None else inputs_embeds.device
+
+ if attention_mask is None:
+ attention_mask = torch.ones((batch_size, seq_len), device=device, dtype=torch.bool)
+
+ if inputs_embeds is None:
+ with torch.no_grad():
+ input_ids, indices, cu_seqlens, max_seqlen, position_ids, labels = _unpad_modernbert_input(
+ inputs=input_ids, attention_mask=attention_mask, position_ids=position_ids, labels=labels
+ )
+ else:
+ inputs_embeds, indices, cu_seqlens, max_seqlen, position_ids, labels = _unpad_modernbert_input(
+ inputs=inputs_embeds, attention_mask=attention_mask, position_ids=position_ids, labels=labels
+ )
+
+ outputs = self.model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ sliding_window_mask=sliding_window_mask,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ indices=indices,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ batch_size=batch_size,
+ seq_len=seq_len,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ last_hidden_state = outputs[0]
+
+ if self.sparse_prediction and labels is not None:
+ # flatten labels and output first
+ labels = labels.view(-1)
+ last_hidden_state = last_hidden_state.view(labels.shape[0], -1)
+
+ # then filter out the non-masked tokens
+ mask_tokens = labels != self.sparse_pred_ignore_index
+ last_hidden_state = last_hidden_state[mask_tokens]
+ labels = labels[mask_tokens]
+
+ logits = (
+ self.compiled_head(last_hidden_state)
+ if self.config.reference_compile
+ else self.decoder(self.head(last_hidden_state))
+ )
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(logits, labels, vocab_size=self.config.vocab_size)
+
+ if self.config._attn_implementation == "flash_attention_2":
+ with nullcontext() if self.config.repad_logits_with_grad or labels is None else torch.no_grad():
+ logits = _pad_modernbert_output(inputs=logits, indices=indices, batch=batch_size, seqlen=seq_len)
+
+ if not return_dict:
+ output = (logits,)
+ return ((loss,) + output) if loss is not None else output
+
+ return MaskedLMOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+@add_start_docstrings(
+ "The ModernBert Model with a sequence classification head on top that performs pooling.",
+ MODERNBERT_START_DOCSTRING,
+)
+class ModernBertForSequenceClassification(ModernBertPreTrainedModel):
+ def __init__(self, config: ModernBertConfig):
+ super().__init__(config)
+ self.num_labels = config.num_labels
+ self.config = config
+
+ self.model = ModernBertModel(config)
+ self.head = ModernBertPredictionHead(config)
+ self.drop = torch.nn.Dropout(config.classifier_dropout)
+ self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @add_start_docstrings_to_model_forward(MODERNBERT_INPUTS_DOCSTRING)
+ @add_code_sample_docstrings(
+ checkpoint=_CHECKPOINT_FOR_DOC,
+ output_type=SequenceClassifierOutput,
+ config_class=_CONFIG_FOR_DOC,
+ )
+ def forward(
+ self,
+ input_ids: Optional[torch.LongTensor] = None,
+ attention_mask: Optional[torch.Tensor] = None,
+ sliding_window_mask: Optional[torch.Tensor] = None,
+ position_ids: Optional[torch.Tensor] = None,
+ inputs_embeds: Optional[torch.Tensor] = None,
+ labels: Optional[torch.Tensor] = None,
+ indices: Optional[torch.Tensor] = None,
+ cu_seqlens: Optional[torch.Tensor] = None,
+ max_seqlen: Optional[int] = None,
+ batch_size: Optional[int] = None,
+ seq_len: Optional[int] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ **kwargs,
+ ) -> Union[Tuple[torch.Tensor], SequenceClassifierOutput]:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+ self._maybe_set_compile()
+
+ outputs = self.model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ sliding_window_mask=sliding_window_mask,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ indices=indices,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ batch_size=batch_size,
+ seq_len=seq_len,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ last_hidden_state = outputs[0]
+
+ if self.config.classifier_pooling == "cls":
+ last_hidden_state = last_hidden_state[:, 0]
+ elif self.config.classifier_pooling == "mean":
+ last_hidden_state = (last_hidden_state * attention_mask.unsqueeze(-1)).sum(dim=1) / attention_mask.sum(
+ dim=1, keepdim=True
+ )
+
+ pooled_output = self.head(last_hidden_state)
+ pooled_output = self.drop(pooled_output)
+ logits = self.classifier(pooled_output)
+
+ loss = None
+ if labels is not None:
+ if self.config.problem_type is None:
+ if self.num_labels == 1:
+ self.config.problem_type = "regression"
+ elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+ self.config.problem_type = "single_label_classification"
+ else:
+ self.config.problem_type = "multi_label_classification"
+
+ if self.config.problem_type == "regression":
+ loss_fct = MSELoss()
+ if self.num_labels == 1:
+ loss = loss_fct(logits.squeeze(), labels.squeeze())
+ else:
+ loss = loss_fct(logits, labels)
+ elif self.config.problem_type == "single_label_classification":
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+ elif self.config.problem_type == "multi_label_classification":
+ loss_fct = BCEWithLogitsLoss()
+ loss = loss_fct(logits, labels)
+
+ if not return_dict:
+ output = (logits,)
+ return ((loss,) + output) if loss is not None else output
+
+ return SequenceClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+@add_start_docstrings(
+ "The ModernBert Model with a token classification head on top, e.g. for Named Entity Recognition (NER) tasks.",
+ MODERNBERT_START_DOCSTRING,
+)
+class ModernBertForTokenClassification(ModernBertPreTrainedModel):
+ def __init__(self, config: ModernBertConfig):
+ super().__init__(config)
+ self.num_labels = config.num_labels
+
+ self.model = ModernBertModel(config)
+ self.head = ModernBertPredictionHead(config)
+ self.drop = torch.nn.Dropout(config.classifier_dropout)
+ self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @add_start_docstrings_to_model_forward(MODERNBERT_INPUTS_DOCSTRING)
+ @add_code_sample_docstrings(
+ checkpoint=_CHECKPOINT_FOR_DOC,
+ output_type=TokenClassifierOutput,
+ config_class=_CONFIG_FOR_DOC,
+ )
+ def forward(
+ self,
+ input_ids: Optional[torch.LongTensor] = None,
+ attention_mask: Optional[torch.Tensor] = None,
+ sliding_window_mask: Optional[torch.Tensor] = None,
+ position_ids: Optional[torch.Tensor] = None,
+ inputs_embeds: Optional[torch.Tensor] = None,
+ labels: Optional[torch.Tensor] = None,
+ indices: Optional[torch.Tensor] = None,
+ cu_seqlens: Optional[torch.Tensor] = None,
+ max_seqlen: Optional[int] = None,
+ batch_size: Optional[int] = None,
+ seq_len: Optional[int] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ ) -> Union[Tuple[torch.Tensor], TokenClassifierOutput]:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the token classification loss. Indices should be in `[0, ..., config.num_labels - 1]`.
+ """
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+ self._maybe_set_compile()
+
+ outputs = self.model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ sliding_window_mask=sliding_window_mask,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ indices=indices,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ batch_size=batch_size,
+ seq_len=seq_len,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ last_hidden_state = outputs[0]
+
+ last_hidden_state = self.head(last_hidden_state)
+ last_hidden_state = self.drop(last_hidden_state)
+ logits = self.classifier(last_hidden_state)
+
+ loss = None
+ if labels is not None:
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+
+ if not return_dict:
+ output = (logits,) + outputs[1:]
+ return ((loss,) + output) if loss is not None else output
+
+ return TokenClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = [
+ "ModernBertModel",
+ "ModernBertPreTrainedModel",
+ "ModernBertForMaskedLM",
+ "ModernBertForSequenceClassification",
+ "ModernBertForTokenClassification",
+]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/modernbert/modular_modernbert.py b/vllm/lib/python3.10/site-packages/transformers/models/modernbert/modular_modernbert.py
new file mode 100644
index 0000000000000000000000000000000000000000..edfdc94346bf122b71f25f981dc30af89bfc5c7a
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/modernbert/modular_modernbert.py
@@ -0,0 +1,1497 @@
+# Copyright 2024 Answer.AI, LightOn, and contributors, and the HuggingFace Inc. team. All rights reserved.
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+from contextlib import nullcontext
+from typing import Dict, Literal, Optional, Tuple, Union
+
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+
+from ...activations import ACT2FN
+from ...configuration_utils import PretrainedConfig
+from ...modeling_attn_mask_utils import _prepare_4d_attention_mask
+from ...modeling_outputs import (
+ BaseModelOutput,
+ MaskedLMOutput,
+ SequenceClassifierOutput,
+ TokenClassifierOutput,
+)
+from ...modeling_utils import PreTrainedModel
+from ...utils import (
+ add_code_sample_docstrings,
+ add_start_docstrings,
+ add_start_docstrings_to_model_forward,
+ is_flash_attn_2_available,
+ logging,
+)
+from ...utils.import_utils import is_triton_available
+from ..gemma.modeling_gemma import GemmaRotaryEmbedding, apply_rotary_pos_emb
+
+
+if is_flash_attn_2_available():
+ from flash_attn.flash_attn_interface import flash_attn_varlen_qkvpacked_func
+ from flash_attn.layers.rotary import RotaryEmbedding
+ from flash_attn.ops.triton.rotary import apply_rotary
+else:
+ RotaryEmbedding = object
+
+_CHECKPOINT_FOR_DOC = "answerdotai/ModernBERT-base"
+_CONFIG_FOR_DOC = "ModernBertConfig"
+
+logger = logging.get_logger(__name__)
+
+
+class ModernBertConfig(PretrainedConfig):
+ r"""
+ This is the configuration class to store the configuration of a [`ModernBertModel`]. It is used to instantiate an ModernBert
+ model according to the specified arguments, defining the model architecture. Instantiating a configuration with the
+ defaults will yield a similar configuration to that of the ModernBERT-base.
+ e.g. [answerdotai/ModernBERT-base](https://huggingface.co/answerdotai/ModernBERT-base)
+
+ Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+ documentation from [`PretrainedConfig`] for more information.
+
+ Args:
+ vocab_size (`int`, *optional*, defaults to 50368):
+ Vocabulary size of the ModernBert model. Defines the number of different tokens that can be represented by the
+ `inputs_ids` passed when calling [`ModernBertModel`]
+ hidden_size (`int`, *optional*, defaults to 768):
+ Dimension of the hidden representations.
+ intermediate_size (`int`, *optional*, defaults to 1152):
+ Dimension of the MLP representations.
+ num_hidden_layers (`int`, *optional*, defaults to 22):
+ Number of hidden layers in the Transformer decoder.
+ num_attention_heads (`int`, *optional*, defaults to 12):
+ Number of attention heads for each attention layer in the Transformer decoder.
+ hidden_activation (`str` or `function`, *optional*, defaults to `"gelu"`):
+ The non-linear activation function (function or string) in the decoder. Will default to `"gelu"`
+ if not specified.
+ max_position_embeddings (`int`, *optional*, defaults to 8192):
+ The maximum sequence length that this model might ever be used with.
+ initializer_range (`float`, *optional*, defaults to 0.02):
+ The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+ initializer_cutoff_factor (`float`, *optional*, defaults to 2.0):
+ The cutoff factor for the truncated_normal_initializer for initializing all weight matrices.
+ norm_eps (`float`, *optional*, defaults to 1e-05):
+ The epsilon used by the rms normalization layers.
+ norm_bias (`bool`, *optional*, defaults to `False`):
+ Whether to use bias in the normalization layers.
+ pad_token_id (`int`, *optional*, defaults to 50283):
+ Padding token id.
+ eos_token_id (`int`, *optional*, defaults to 50282):
+ End of stream token id.
+ bos_token_id (`int`, *optional*, defaults to 50281):
+ Beginning of stream token id.
+ cls_token_id (`int`, *optional*, defaults to 50281):
+ Classification token id.
+ sep_token_id (`int`, *optional*, defaults to 50282):
+ Separation token id.
+ global_rope_theta (`float`, *optional*, defaults to 160000.0):
+ The base period of the global RoPE embeddings.
+ attention_bias (`bool`, *optional*, defaults to `False`):
+ Whether to use a bias in the query, key, value and output projection layers during self-attention.
+ attention_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout ratio for the attention probabilities.
+ global_attn_every_n_layers (`int`, *optional*, defaults to 3):
+ The number of layers between global attention layers.
+ local_attention (`int`, *optional*, defaults to 128):
+ The window size for local attention.
+ local_rope_theta (`float`, *optional*, defaults to 10000.0):
+ The base period of the local RoPE embeddings.
+ embedding_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout ratio for the embeddings.
+ mlp_bias (`bool`, *optional*, defaults to `False`):
+ Whether to use bias in the MLP layers.
+ mlp_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout ratio for the MLP layers.
+ decoder_bias (`bool`, *optional*, defaults to `True`):
+ Whether to use bias in the decoder layers.
+ classifier_pooling (`str`, *optional*, defaults to `"cls"`):
+ The pooling method for the classifier. Should be either `"cls"` or `"mean"`. In local attention layers, the
+ CLS token doesn't attend to all tokens on long sequences.
+ classifier_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout ratio for the classifier.
+ classifier_bias (`bool`, *optional*, defaults to `False`):
+ Whether to use bias in the classifier.
+ classifier_activation (`str`, *optional*, defaults to `"gelu"`):
+ The activation function for the classifier.
+ deterministic_flash_attn (`bool`, *optional*, defaults to `False`):
+ Whether to use deterministic flash attention. If `False`, inference will be faster but not deterministic.
+ sparse_prediction (`bool`, *optional*, defaults to `False`):
+ Whether to use sparse prediction for the masked language model instead of returning the full dense logits.
+ sparse_pred_ignore_index (`int`, *optional*, defaults to -100):
+ The index to ignore for the sparse prediction.
+ reference_compile (`bool`, *optional*):
+ Whether to compile the layers of the model which were compiled during pretraining. If `None`, then parts of
+ the model will be compiled if 1) `triton` is installed, 2) the model is not on MPS, 3) the model is not
+ shared between devices, and 4) the model is not resized after initialization. If `True`, then the model may
+ be faster in some scenarios.
+ repad_logits_with_grad (`bool`, *optional*, defaults to `False`):
+ When True, ModernBertForMaskedLM keeps track of the logits' gradient when repadding for output. This only
+ applies when using Flash Attention 2 with passed labels. Otherwise output logits always have a gradient.
+
+ Examples:
+
+ ```python
+ >>> from transformers import ModernBertModel, ModernBertConfig
+
+ >>> # Initializing a ModernBert style configuration
+ >>> configuration = ModernBertConfig()
+
+ >>> # Initializing a model from the modernbert-base style configuration
+ >>> model = ModernBertModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "modernbert"
+ keys_to_ignore_at_inference = ["past_key_values"]
+
+ def __init__(
+ self,
+ vocab_size=50368,
+ hidden_size=768,
+ intermediate_size=1152,
+ num_hidden_layers=22,
+ num_attention_heads=12,
+ hidden_activation="gelu",
+ max_position_embeddings=8192,
+ initializer_range=0.02,
+ initializer_cutoff_factor=2.0,
+ norm_eps=1e-5,
+ norm_bias=False,
+ pad_token_id=50283,
+ eos_token_id=50282,
+ bos_token_id=50281,
+ cls_token_id=50281,
+ sep_token_id=50282,
+ global_rope_theta=160000.0,
+ attention_bias=False,
+ attention_dropout=0.0,
+ global_attn_every_n_layers=3,
+ local_attention=128,
+ local_rope_theta=10000.0,
+ embedding_dropout=0.0,
+ mlp_bias=False,
+ mlp_dropout=0.0,
+ decoder_bias=True,
+ classifier_pooling: Literal["cls", "mean"] = "cls",
+ classifier_dropout=0.0,
+ classifier_bias=False,
+ classifier_activation="gelu",
+ deterministic_flash_attn=False,
+ sparse_prediction=False,
+ sparse_pred_ignore_index=-100,
+ reference_compile=None,
+ repad_logits_with_grad=False,
+ **kwargs,
+ ):
+ super().__init__(
+ pad_token_id=pad_token_id,
+ bos_token_id=bos_token_id,
+ eos_token_id=eos_token_id,
+ cls_token_id=cls_token_id,
+ sep_token_id=sep_token_id,
+ **kwargs,
+ )
+ self.vocab_size = vocab_size
+ self.max_position_embeddings = max_position_embeddings
+ self.hidden_size = hidden_size
+ self.intermediate_size = intermediate_size
+ self.num_hidden_layers = num_hidden_layers
+ self.num_attention_heads = num_attention_heads
+ self.initializer_range = initializer_range
+ self.initializer_cutoff_factor = initializer_cutoff_factor
+ self.norm_eps = norm_eps
+ self.norm_bias = norm_bias
+ self.global_rope_theta = global_rope_theta
+ self.attention_bias = attention_bias
+ self.attention_dropout = attention_dropout
+ self.hidden_activation = hidden_activation
+ self.global_attn_every_n_layers = global_attn_every_n_layers
+ self.local_attention = local_attention
+ self.local_rope_theta = local_rope_theta
+ self.embedding_dropout = embedding_dropout
+ self.mlp_bias = mlp_bias
+ self.mlp_dropout = mlp_dropout
+ self.decoder_bias = decoder_bias
+ self.classifier_pooling = classifier_pooling
+ self.classifier_dropout = classifier_dropout
+ self.classifier_bias = classifier_bias
+ self.classifier_activation = classifier_activation
+ self.deterministic_flash_attn = deterministic_flash_attn
+ self.sparse_prediction = sparse_prediction
+ self.sparse_pred_ignore_index = sparse_pred_ignore_index
+ self.reference_compile = reference_compile
+ self.repad_logits_with_grad = repad_logits_with_grad
+
+ if self.classifier_pooling not in ["cls", "mean"]:
+ raise ValueError(
+ f'Invalid value for `classifier_pooling`, should be either "cls" or "mean", but is {self.classifier_pooling}.'
+ )
+
+
+def _unpad_modernbert_input(
+ inputs: torch.Tensor,
+ attention_mask: torch.Tensor,
+ position_ids: Optional[torch.Tensor] = None,
+ labels: Optional[torch.Tensor] = None,
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, int, Optional[torch.Tensor], Optional[torch.Tensor]]:
+ """
+ Remove padding from input sequences.
+
+ Args:
+ inputs: (batch, seqlen, ...) or (batch, seqlen)
+ attention_mask: (batch, seqlen), bool / int, 1 means valid and 0 means not valid.
+ position_ids: (batch, seqlen), int, position ids
+ labels: (batch, seqlen), int, labels
+
+ Returns:
+ unpadded_inputs: (total_nnz, ...), where total_nnz = number of tokens selected in attention_mask.
+ indices: (total_nnz)
+ cu_seqlens: (batch + 1), the cumulative sequence lengths
+ max_seqlen_in_batch: int
+ unpadded_position_ids: (total_nnz) or None
+ unpadded_labels: (total_nnz) or None
+ """
+ seqlens_in_batch = attention_mask.sum(dim=-1, dtype=torch.int32)
+ indices = torch.nonzero(attention_mask.flatten(), as_tuple=False).flatten()
+ max_seqlen_in_batch = int(seqlens_in_batch.max().item())
+ cu_seqlens = torch.nn.functional.pad(torch.cumsum(seqlens_in_batch, dim=0, dtype=torch.int32), (1, 0))
+
+ if inputs.dim() == 2:
+ unpadded_inputs = inputs.flatten()[indices]
+ else:
+ batch, seqlen, *rest = inputs.shape
+ shape = batch * seqlen
+ unpadded_inputs = inputs.view(shape, *rest)[indices]
+
+ unpadded_position_ids = position_ids.flatten()[indices] if position_ids is not None else None
+ unpadded_labels = labels.flatten()[indices] if labels is not None else None
+
+ return unpadded_inputs, indices, cu_seqlens, max_seqlen_in_batch, unpadded_position_ids, unpadded_labels
+
+
+def _pad_modernbert_output(
+ inputs: torch.Tensor,
+ indices: torch.Tensor,
+ batch: int,
+ seqlen: int,
+) -> torch.Tensor:
+ """
+ Add padding to sequences.
+
+ Args:
+ inputs: (total_nnz, ...) or (total_nnz,), where total_nnz = number of tokens selected in attention_mask.
+ indices: (total_nnz)
+ batch: int, batch size
+ seqlen: int, max sequence length
+
+ Returns:
+ padded_inputs: (batch, seqlen, ...) or (batch, seqlen)
+ """
+ if inputs.dim() == 1:
+ output = torch.zeros(batch * seqlen, dtype=inputs.dtype, device=inputs.device)
+ output[indices] = inputs
+ padded_inputs = output.view(batch, seqlen)
+ else:
+ _, *rest = inputs.shape
+ output = torch.zeros(batch * seqlen, *rest, dtype=inputs.dtype, device=inputs.device)
+ output[indices] = inputs
+ padded_inputs = output.view(batch, seqlen, *rest)
+
+ return padded_inputs
+
+
+class ApplyRotaryEmbUnpad(torch.autograd.Function):
+ @staticmethod
+ def forward(
+ ctx,
+ qkv,
+ cos,
+ sin,
+ cu_seqlens: Optional[torch.Tensor] = None,
+ max_seqlen: Optional[int] = None,
+ ):
+ # (total_nnz, 3, nheads, headdim)
+ qkv = qkv.contiguous()
+ total_nnz, _three, _nheads, headdim = qkv.shape
+ # We need qkv to be contiguous so that when we reshape to combine (3, nheads) dimensions,
+ # we get the same tensor
+ # qk = rearrange(qkv[:, :2], "b_s t h d -> b_s (t h) d")
+ qk = qkv[:, :2].view(total_nnz, -1, headdim)
+ apply_rotary(
+ qk,
+ cos,
+ sin,
+ seqlen_offsets=0,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ interleaved=False,
+ inplace=True,
+ )
+
+ ctx.save_for_backward(cos, sin, cu_seqlens)
+ ctx.max_seqlen = max_seqlen
+ return qkv
+
+ @staticmethod
+ def backward(ctx, do):
+ cos, sin, cu_seqlens = ctx.saved_tensors
+ do = do.contiguous()
+ total_nnz, _three, _nheads, headdim = do.shape
+ # We need dqkv to be contiguous so that when we reshape to combine (3, nheads) dimensions,
+ # we get the same tensor
+ dqk = do[:, :2].view(total_nnz, -1, headdim)
+ apply_rotary(
+ dqk,
+ cos,
+ sin,
+ seqlen_offsets=0,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=ctx.max_seqlen,
+ interleaved=False,
+ inplace=True,
+ conjugate=True,
+ )
+
+ return do, None, None, None, None, None, None
+
+
+def apply_rotary_unpadded(
+ qkv,
+ cos,
+ sin,
+ cu_seqlens: Optional[torch.Tensor] = None,
+ max_seqlen: Optional[int] = None,
+):
+ """
+ Arguments:
+ qkv: (total_nnz, 3, nheads, headdim) - input tensor for packed QKV.
+ cos, sin: (seqlen_rotary, rotary_dim / 2)
+ interleaved: if True, rotate pairs of even and odd dimensions (GPT-J style) instead
+ of 1st half and 2nd half (GPT-NeoX style).
+ inplace: if True, apply rotary embedding in-place.
+ seqlen_offsets: (batch_size,) or int. Each sequence in x is shifted by this amount.
+ Most commonly used in inference when we have KV cache.
+ cu_seqlens: (batch + 1,) or None
+ max_seqlen: int
+ Return:
+ out: (total_nnz, dim)
+ rotary_dim must be <= headdim
+ Apply rotary embedding to the first rotary_dim of x.
+ """
+ return ApplyRotaryEmbUnpad.apply(qkv, cos, sin, cu_seqlens, max_seqlen)
+
+
+class ModernBertUnpaddedRotaryEmbedding(RotaryEmbedding):
+ """
+ The rotary position embeddings applied directly to unpadded sequences.
+ """
+
+ def __init__(
+ self,
+ dim: int,
+ base: float = 10000.0,
+ max_seqlen: Optional[int] = None,
+ device: Optional[torch.device] = None,
+ dtype: Optional[torch.dtype] = None,
+ ):
+ """
+ max_seqlen: if max_seqlen, device, and dtype are provided, we precompute the cos_sin_cache
+ up to max_seqlen. If the max_seqlen, device, or dtype during training/inference differ,
+ the cos_sin_cache wll be recomputed during the forward pass.
+ """
+ super().__init__(dim=dim, base=base, pos_idx_in_fp32=True, device=device, interleaved=False)
+ self.max_seqlen = max_seqlen
+
+ if max_seqlen is not None and device is not None and dtype is not None:
+ self._update_cos_sin_cache(max_seqlen, device=device, dtype=dtype)
+
+ def forward(
+ self,
+ qkv: torch.Tensor,
+ cu_seqlens: torch.Tensor,
+ max_seqlen: Optional[int] = None,
+ ) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:
+ """
+ Apply rotary embedding *inplace* to qkv.
+ qkv: (total_nnz, 3, nheads, headdim)
+ cu_seqlens: (batch + 1,) cumulative sequence lengths
+ max_seqlen: int max seq length in the batch
+ """
+ if max_seqlen is not None:
+ self._update_cos_sin_cache(max_seqlen, device=qkv.device, dtype=qkv.dtype)
+
+ qkv = apply_rotary_unpadded(
+ qkv,
+ self._cos_cached,
+ self._sin_cached,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ )
+
+ return qkv
+
+ def extra_repr(self) -> str:
+ return f"dim={self.dim}, base={self.base}, scale_base={self.scale_base}"
+
+
+class ModernBertEmbeddings(nn.Module):
+ """
+ Same as BertEmbeddings with a tiny tweak for positional embeddings indexing.
+ """
+
+ def __init__(self, config: ModernBertConfig):
+ super().__init__()
+ self.config = config
+ self.tok_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
+ self.norm = nn.LayerNorm(config.hidden_size, eps=config.norm_eps, bias=config.norm_bias)
+ self.drop = nn.Dropout(config.embedding_dropout)
+
+ @torch.compile(dynamic=True)
+ def compiled_embeddings(self, input_ids: torch.LongTensor) -> torch.Tensor:
+ return self.drop(self.norm(self.tok_embeddings(input_ids)))
+
+ def forward(
+ self, input_ids: torch.LongTensor = None, inputs_embeds: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ if inputs_embeds is not None:
+ hidden_states = self.drop(self.norm(inputs_embeds))
+ else:
+ hidden_states = (
+ self.compiled_embeddings(input_ids)
+ if self.config.reference_compile
+ else self.drop(self.norm(self.tok_embeddings(input_ids)))
+ )
+ return hidden_states
+
+
+class ModernBertMLP(nn.Module):
+ """Applies the GLU at the end of each ModernBERT layer.
+
+ Compared to the default BERT architecture, this block replaces :class:`~transformers.model.bert.modeling_bert.BertIntermediate`
+ and :class:`~transformers.model.bert.modeling_bert.SelfOutput` with a single module that has similar functionality.
+ """
+
+ def __init__(self, config: ModernBertConfig):
+ super().__init__()
+ self.config = config
+ self.Wi = nn.Linear(config.hidden_size, int(config.intermediate_size) * 2, bias=config.mlp_bias)
+ self.act = ACT2FN[config.hidden_activation]
+ self.drop = nn.Dropout(config.mlp_dropout)
+ self.Wo = nn.Linear(config.intermediate_size, config.hidden_size, bias=config.mlp_bias)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ input, gate = self.Wi(hidden_states).chunk(2, dim=-1)
+ return self.Wo(self.drop(self.act(input) * gate))
+
+
+class ModernBertRotaryEmbedding(GemmaRotaryEmbedding):
+ def __init__(self, config: ModernBertConfig, dim: int, base: float, device: Optional[torch.device] = None):
+ super().__init__(self, config=config, device=device)
+ inv_freq, self.attention_scaling = self.rope_init_fn(None, device, dim=dim, base=base)
+
+
+def eager_attention_forward(
+ module: "ModernBertAttention",
+ qkv: torch.Tensor,
+ attention_mask: torch.Tensor,
+ sliding_window_mask: torch.Tensor,
+ position_ids: Optional[torch.LongTensor],
+ local_attention: Tuple[int, int],
+ bs: int,
+ dim: int,
+ output_attentions: Optional[bool] = False,
+ **_kwargs,
+) -> Union[Tuple[torch.Tensor, torch.Tensor], Tuple[torch.Tensor]]:
+ # qkv: [batch_size, seqlen, 3, nheads, headdim]
+ cos, sin = module.rotary_emb(qkv, position_ids=position_ids)
+ query, key, value = qkv.transpose(3, 1).unbind(dim=2)
+ # query, key, value: [batch_size, heads, seq_len, head_dim]
+ query, key = apply_rotary_pos_emb(query, key, cos, sin)
+
+ scale = module.head_dim**-0.5
+ attn_weights = torch.matmul(query, key.transpose(2, 3)) * scale
+
+ if local_attention != (-1, -1):
+ attention_mask = sliding_window_mask
+
+ attn_weights = attn_weights + attention_mask
+
+ # upcast attention to fp32
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)
+ attn_weights = nn.functional.dropout(attn_weights, p=module.attention_dropout, training=module.training)
+ attn_output = torch.matmul(attn_weights, value)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+ attn_output = attn_output.view(bs, -1, dim)
+ if output_attentions:
+ return (attn_output, attn_weights)
+ return (attn_output,)
+
+
+def flash_attention_forward(
+ module: "ModernBertAttention",
+ qkv: torch.Tensor,
+ rotary_emb: ModernBertUnpaddedRotaryEmbedding,
+ cu_seqlens: torch.Tensor,
+ max_seqlen: int,
+ local_attention: Tuple[int, int],
+ bs: int,
+ dim: int,
+ target_dtype: torch.dtype = torch.bfloat16,
+ **_kwargs,
+) -> Tuple[torch.Tensor]:
+ # (total_seqlen, 3, nheads, headdim)
+ qkv = rotary_emb(qkv, cu_seqlens=cu_seqlens, max_seqlen=max_seqlen)
+
+ convert_dtype = qkv.dtype not in (torch.float16, torch.bfloat16)
+ if convert_dtype:
+ # FA2 implementation only supports fp16 and bf16. If FA2 is supported,
+ # bfloat16 must be supported as of FA2 2.5.7. (Turing GPUs not supported)
+ orig_dtype = qkv.dtype
+ qkv = qkv.to(target_dtype)
+
+ attn = flash_attn_varlen_qkvpacked_func(
+ qkv,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ dropout_p=module.attention_dropout if module.training else 0.0,
+ deterministic=module.deterministic_flash_attn,
+ window_size=local_attention,
+ )
+ attn = attn.to(orig_dtype) # type: ignore
+ else:
+ attn = flash_attn_varlen_qkvpacked_func(
+ qkv,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ dropout_p=module.attention_dropout if module.training else 0.0,
+ deterministic=module.deterministic_flash_attn,
+ window_size=local_attention,
+ )
+ return (attn.view(bs, dim),)
+
+
+def sdpa_attention_forward(
+ module: "ModernBertAttention",
+ qkv: torch.Tensor,
+ attention_mask: torch.Tensor,
+ sliding_window_mask: torch.Tensor,
+ position_ids: Optional[torch.LongTensor],
+ local_attention: Tuple[int, int],
+ bs: int,
+ dim: int,
+ **_kwargs,
+) -> Tuple[torch.Tensor]:
+ # qkv: [batch_size, seqlen, 3, nheads, headdim]
+ cos, sin = module.rotary_emb(qkv, position_ids=position_ids)
+ query, key, value = qkv.transpose(3, 1).unbind(dim=2)
+ # query, key, value: [batch_size, heads, seq_len, head_dim]
+ query, key = apply_rotary_pos_emb(query, key, cos, sin)
+
+ if local_attention != (-1, -1):
+ attention_mask = sliding_window_mask
+
+ attn_output = (
+ F.scaled_dot_product_attention(
+ query,
+ key,
+ value,
+ dropout_p=module.attention_dropout if module.training else 0.0,
+ attn_mask=attention_mask,
+ )
+ .transpose(1, 2)
+ .contiguous()
+ )
+ attn_output = attn_output.view(bs, -1, dim)
+ return (attn_output,)
+
+
+MODERNBERT_ATTENTION_FUNCTION = {
+ "flash_attention_2": flash_attention_forward,
+ "eager": eager_attention_forward,
+ "sdpa": sdpa_attention_forward,
+}
+
+
+class ModernBertAttention(nn.Module):
+ """Performs multi-headed self attention on a batch of unpadded sequences.
+
+ If Flash Attention 2 is installed, this module uses Flash Attention to improve throughput.
+ If Flash Attention 2 is not installed, the implementation will use PyTorch's SDPA kernel,
+ which requires padding and unpadding inputs, adding some overhead.
+
+ See `forward` method for additional details.
+ """
+
+ def __init__(self, config: ModernBertConfig, layer_id: Optional[int] = None):
+ super().__init__()
+ self.config = config
+ self.layer_id = layer_id
+
+ if config.hidden_size % config.num_attention_heads != 0:
+ raise ValueError(
+ f"The hidden size ({config.hidden_size}) is not a multiple of the number of attention heads ({config.num_attention_heads})"
+ )
+
+ self.attention_dropout = config.attention_dropout
+ self.deterministic_flash_attn = config.deterministic_flash_attn
+ self.num_heads = config.num_attention_heads
+ self.head_dim = config.hidden_size // config.num_attention_heads
+ self.all_head_size = self.head_dim * self.num_heads
+ self.Wqkv = nn.Linear(config.hidden_size, 3 * self.all_head_size, bias=config.attention_bias)
+
+ if layer_id % config.global_attn_every_n_layers != 0:
+ self.local_attention = (config.local_attention // 2, config.local_attention // 2)
+ else:
+ self.local_attention = (-1, -1)
+
+ rope_theta = config.global_rope_theta
+ max_position_embeddings = config.max_position_embeddings
+ if self.local_attention != (-1, -1):
+ if config.local_rope_theta is not None:
+ rope_theta = config.local_rope_theta
+ max_position_embeddings = config.local_attention
+
+ if config._attn_implementation == "flash_attention_2":
+ self.rotary_emb = ModernBertUnpaddedRotaryEmbedding(
+ dim=self.head_dim, max_seqlen=max_position_embeddings, base=rope_theta
+ )
+ else:
+ self.rotary_emb = ModernBertRotaryEmbedding(config=config, dim=self.head_dim, base=rope_theta)
+
+ self.Wo = nn.Linear(config.hidden_size, config.hidden_size, bias=config.attention_bias)
+ self.out_drop = nn.Dropout(config.attention_dropout) if config.attention_dropout > 0.0 else nn.Identity()
+ self.pruned_heads = set()
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ output_attentions: Optional[bool] = False,
+ **kwargs,
+ ) -> torch.Tensor:
+ qkv = self.Wqkv(hidden_states)
+
+ bs = hidden_states.shape[0]
+ if self.config._attn_implementation == "flash_attention_2":
+ qkv = qkv.view(-1, 3, self.num_heads, self.head_dim)
+ else:
+ qkv = qkv.view(bs, -1, 3, self.num_heads, self.head_dim)
+
+ attn_outputs = MODERNBERT_ATTENTION_FUNCTION[self.config._attn_implementation](
+ self,
+ qkv=qkv,
+ rotary_emb=self.rotary_emb,
+ local_attention=self.local_attention,
+ bs=bs,
+ dim=self.all_head_size,
+ output_attentions=output_attentions,
+ **kwargs,
+ )
+ hidden_states = attn_outputs[0]
+ hidden_states = self.out_drop(self.Wo(hidden_states))
+
+ return (hidden_states,) + attn_outputs[1:] # add attentions if outputted
+
+
+class ModernBertEncoderLayer(nn.Module):
+ def __init__(self, config: ModernBertConfig, layer_id: Optional[int] = None):
+ super().__init__()
+ self.config = config
+ if layer_id == 0:
+ self.attn_norm = nn.Identity()
+ else:
+ self.attn_norm = nn.LayerNorm(config.hidden_size, eps=config.norm_eps, bias=config.norm_bias)
+ self.attn = ModernBertAttention(config=config, layer_id=layer_id)
+ self.mlp_norm = nn.LayerNorm(config.hidden_size, eps=config.norm_eps, bias=config.norm_bias)
+ self.mlp = ModernBertMLP(config)
+
+ @torch.compile(dynamic=True)
+ def compiled_mlp(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ return self.mlp(self.mlp_norm(hidden_states))
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: Optional[torch.Tensor] = None,
+ sliding_window_mask: Optional[torch.Tensor] = None,
+ position_ids: Optional[torch.LongTensor] = None,
+ cu_seqlens: Optional[torch.Tensor] = None,
+ max_seqlen: Optional[int] = None,
+ output_attentions: Optional[bool] = False,
+ ) -> torch.Tensor:
+ attn_outputs = self.attn(
+ self.attn_norm(hidden_states),
+ attention_mask=attention_mask,
+ sliding_window_mask=sliding_window_mask,
+ position_ids=position_ids,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ output_attentions=output_attentions,
+ )
+ hidden_states = hidden_states + attn_outputs[0]
+ mlp_output = (
+ self.compiled_mlp(hidden_states)
+ if self.config.reference_compile
+ else self.mlp(self.mlp_norm(hidden_states))
+ )
+ hidden_states = hidden_states + mlp_output
+
+ return (hidden_states,) + attn_outputs[1:] # add attentions if outputted
+
+
+MODERNBERT_START_DOCSTRING = r"""
+ This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
+ library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
+ etc.)
+
+ This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
+ Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
+ and behavior.
+
+ Parameters:
+ config ([`ModernBertConfig`]):
+ Model configuration class with all the parameters of the model. Initializing with a config file does not
+ load the weights associated with the model, only the configuration. Check out the
+ [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+"""
+
+
+@add_start_docstrings(
+ "The bare ModernBert Model outputting raw hidden-states without any specific head on top.",
+ MODERNBERT_START_DOCSTRING,
+)
+class ModernBertPreTrainedModel(PreTrainedModel):
+ config_class = ModernBertConfig
+ base_model_prefix = "model"
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["ModernBertEmbeddings", "ModernBertEncoderLayer"]
+ _supports_flash_attn_2 = True
+ _supports_sdpa = True
+ _supports_flex_attn = False
+
+ def _init_weights(self, module: nn.Module):
+ cutoff_factor = self.config.initializer_cutoff_factor
+ if cutoff_factor is None:
+ cutoff_factor = 3
+
+ def init_weight(module: nn.Module, std: float):
+ nn.init.trunc_normal_(
+ module.weight,
+ mean=0.0,
+ std=std,
+ a=-cutoff_factor * std,
+ b=cutoff_factor * std,
+ )
+
+ if isinstance(module, nn.Linear):
+ if module.bias is not None:
+ nn.init.zeros_(module.bias)
+
+ stds = {
+ "in": self.config.initializer_range,
+ "out": self.config.initializer_range / math.sqrt(2.0 * self.config.num_hidden_layers),
+ "embedding": self.config.initializer_range,
+ "final_out": self.config.hidden_size**-0.5,
+ }
+
+ if isinstance(module, ModernBertEmbeddings):
+ init_weight(module.tok_embeddings, stds["embedding"])
+ elif isinstance(module, ModernBertMLP):
+ init_weight(module.Wi, stds["in"])
+ init_weight(module.Wo, stds["out"])
+ elif isinstance(module, ModernBertAttention):
+ init_weight(module.Wqkv, stds["in"])
+ init_weight(module.Wo, stds["out"])
+ elif isinstance(module, ModernBertPredictionHead):
+ init_weight(module.dense, stds["out"])
+ elif isinstance(module, ModernBertForMaskedLM):
+ init_weight(module.decoder, stds["out"])
+ elif isinstance(module, (ModernBertForSequenceClassification, ModernBertForTokenClassification)):
+ init_weight(module.classifier, stds["final_out"])
+
+ @classmethod
+ def _autoset_attn_implementation(
+ cls,
+ config,
+ use_flash_attention_2: bool = False,
+ torch_dtype: Optional[torch.dtype] = None,
+ device_map: Optional[Union[str, Dict[str, int]]] = None,
+ check_device_map: bool = True,
+ ):
+ # If the user didn't specify anything, try to use flash_attention_2 if available.
+ # Otherwise we fall back to the default SDPA -> Eager from the super() method.
+ # ModernBert's FA2 implementation correctly handles non-fp16/bf16 dtypes, we don't
+ # need the FA2 warning for non-fp16/bf16 dtypes so we set fp16 for the FA2 check.
+ if config._attn_implementation_internal is None:
+ config._attn_implementation_internal = "flash_attention_2"
+ try:
+ return cls._check_and_enable_flash_attn_2(
+ config,
+ torch_dtype=torch.float16,
+ device_map=device_map,
+ hard_check_only=False,
+ check_device_map=check_device_map,
+ )
+ except (ValueError, ImportError):
+ config._attn_implementation_internal = None
+ return super()._autoset_attn_implementation(
+ config,
+ use_flash_attention_2=use_flash_attention_2,
+ torch_dtype=torch.float16,
+ device_map=device_map,
+ check_device_map=check_device_map,
+ )
+
+ def _maybe_set_compile(self):
+ if self.config.reference_compile is False:
+ return
+
+ if hasattr(self, "hf_device_map") and len(self.hf_device_map) > 1:
+ if self.config.reference_compile:
+ logger.warning_once(
+ "If `accelerate` split the model across devices, `torch.compile` will not work. "
+ "Falling back to non-compiled mode."
+ )
+ self.config.reference_compile = False
+
+ if self.device.type == "mps":
+ if self.config.reference_compile:
+ logger.warning_once(
+ "Compiling the model with `torch.compile` and using a `torch.mps` device is not supported. "
+ "Falling back to non-compiled mode."
+ )
+ self.config.reference_compile = False
+
+ if self.device.type == "cpu":
+ if self.config.reference_compile:
+ logger.warning_once(
+ "Compiling the model with `torch.compile` and using a `torch.cpu` device is not supported. "
+ "Falling back to non-compiled mode."
+ )
+ self.config.reference_compile = False
+
+ if self.config.reference_compile is None:
+ self.config.reference_compile = is_triton_available()
+
+ def resize_token_embeddings(self, *args, **kwargs):
+ model_embeds = super().resize_token_embeddings(*args, **kwargs)
+
+ if self.config.reference_compile in {True, None}:
+ if self.config.reference_compile:
+ logger.warning_once(
+ "Resizing token embeddings with `torch.compile` is not supported. Falling back to non-compiled mode."
+ )
+ self.config.reference_compile = False
+
+ return model_embeds
+
+
+MODERNBERT_INPUTS_DOCSTRING = r"""
+ Args:
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary. With Flash Attention 2.0, padding will be ignored
+ by default should you provide it.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are input IDs?](../glossary#input-ids)
+ attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+
+ - 1 for tokens that are **not masked**,
+ - 0 for tokens that are **masked**.
+
+ [What are attention masks?](../glossary#attention-mask)
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ If you want to change padding behavior, you should read [`modeling_opt._prepare_decoder_attention_mask`]
+ and modify to your needs. See diagram 1 in [the paper](https://arxiv.org/abs/1910.13461) for more
+ information on the default strategy.
+
+ - 1 indicates the head is **not masked**,
+ - 0 indicates the head is **masked**.
+ sliding_window_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing attention on padding or far-away tokens. In ModernBert, only every few layers
+ perform global attention, while the rest perform local attention. This mask is used to avoid attending to
+ far-away tokens in the local attention layers when not using Flash Attention.
+ position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.n_positions - 1]`.
+
+ [What are position IDs?](../glossary#position-ids)
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+ Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
+ is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
+ model's internal embedding lookup matrix.
+ indices (`torch.Tensor` of shape `(total_unpadded_tokens,)`, *optional*):
+ Indices of the non-padding tokens in the input sequence. Used for unpadding the output.
+ cu_seqlens (`torch.Tensor` of shape `(batch + 1,)`, *optional*):
+ Cumulative sequence lengths of the input sequences. Used to index the unpadded tensors.
+ max_seqlen (`int`, *optional*):
+ Maximum sequence length in the batch excluding padding tokens. Used to unpad input_ids and pad output tensors.
+ batch_size (`int`, *optional*):
+ Batch size of the input sequences. Used to pad the output tensors.
+ seq_len (`int`, *optional*):
+ Sequence length of the input sequences including padding tokens. Used to pad the output tensors.
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
+ tensors for more detail.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+ more detail.
+ return_dict (`bool`, *optional*):
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+"""
+
+
+@add_start_docstrings(
+ "The bare ModernBert Model outputting raw hidden-states without any specific head on top.",
+ MODERNBERT_START_DOCSTRING,
+)
+class ModernBertModel(ModernBertPreTrainedModel):
+ def __init__(self, config: ModernBertConfig):
+ super().__init__(config)
+ self.config = config
+ self.embeddings = ModernBertEmbeddings(config)
+ self.layers = nn.ModuleList(
+ [ModernBertEncoderLayer(config, layer_id) for layer_id in range(config.num_hidden_layers)]
+ )
+ self.final_norm = nn.LayerNorm(config.hidden_size, eps=config.norm_eps, bias=config.norm_bias)
+ self.gradient_checkpointing = False
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.embeddings.tok_embeddings
+
+ def set_input_embeddings(self, value):
+ self.embeddings.tok_embeddings = value
+
+ @add_start_docstrings_to_model_forward(MODERNBERT_INPUTS_DOCSTRING)
+ @add_code_sample_docstrings(
+ checkpoint=_CHECKPOINT_FOR_DOC,
+ output_type=BaseModelOutput,
+ config_class=_CONFIG_FOR_DOC,
+ )
+ def forward(
+ self,
+ input_ids: Optional[torch.LongTensor] = None,
+ attention_mask: Optional[torch.Tensor] = None,
+ sliding_window_mask: Optional[torch.Tensor] = None,
+ position_ids: Optional[torch.LongTensor] = None,
+ inputs_embeds: Optional[torch.Tensor] = None,
+ indices: Optional[torch.Tensor] = None,
+ cu_seqlens: Optional[torch.Tensor] = None,
+ max_seqlen: Optional[int] = None,
+ batch_size: Optional[int] = None,
+ seq_len: Optional[int] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ ) -> Union[Tuple[torch.Tensor, ...], BaseModelOutput]:
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+ all_hidden_states = () if output_hidden_states else None
+ all_self_attentions = () if output_attentions else None
+
+ self._maybe_set_compile()
+
+ if input_ids is not None:
+ self.warn_if_padding_and_no_attention_mask(input_ids, attention_mask)
+
+ if batch_size is None and seq_len is None:
+ if inputs_embeds is not None:
+ batch_size, seq_len = inputs_embeds.shape[:2]
+ else:
+ batch_size, seq_len = input_ids.shape[:2]
+ device = input_ids.device if input_ids is not None else inputs_embeds.device
+
+ if attention_mask is None:
+ attention_mask = torch.ones((batch_size, seq_len), device=device, dtype=torch.bool)
+
+ repad = False
+ if self.config._attn_implementation == "flash_attention_2":
+ if indices is None and cu_seqlens is None and max_seqlen is None:
+ repad = True
+ if inputs_embeds is None:
+ with torch.no_grad():
+ input_ids, indices, cu_seqlens, max_seqlen, *_ = _unpad_modernbert_input(
+ inputs=input_ids, attention_mask=attention_mask
+ )
+ else:
+ inputs_embeds, indices, cu_seqlens, max_seqlen, *_ = _unpad_modernbert_input(
+ inputs=inputs_embeds, attention_mask=attention_mask
+ )
+ else:
+ if position_ids is None:
+ position_ids = torch.arange(seq_len, device=device).unsqueeze(0)
+
+ attention_mask, sliding_window_mask = self._update_attention_mask(
+ attention_mask, output_attentions=output_attentions
+ )
+
+ hidden_states = self.embeddings(input_ids=input_ids, inputs_embeds=inputs_embeds)
+
+ for encoder_layer in self.layers:
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ if self.gradient_checkpointing and self.training:
+ layer_outputs = self._gradient_checkpointing_func(
+ encoder_layer.__call__,
+ hidden_states,
+ attention_mask,
+ sliding_window_mask,
+ position_ids,
+ cu_seqlens,
+ max_seqlen,
+ output_attentions,
+ )
+ else:
+ layer_outputs = encoder_layer(
+ hidden_states,
+ attention_mask=attention_mask,
+ sliding_window_mask=sliding_window_mask,
+ position_ids=position_ids,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ output_attentions=output_attentions,
+ )
+ hidden_states = layer_outputs[0]
+ if output_attentions and len(layer_outputs) > 1:
+ all_self_attentions = all_self_attentions + (layer_outputs[1],)
+
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ hidden_states = self.final_norm(hidden_states)
+
+ if repad:
+ hidden_states = _pad_modernbert_output(
+ inputs=hidden_states, indices=indices, batch=batch_size, seqlen=seq_len
+ )
+ if all_hidden_states is not None:
+ all_hidden_states = tuple(
+ _pad_modernbert_output(inputs=hs, indices=indices, batch=batch_size, seqlen=seq_len)
+ for hs in all_hidden_states
+ )
+
+ if not return_dict:
+ return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None)
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ hidden_states=all_hidden_states,
+ attentions=all_self_attentions,
+ )
+
+ def _update_attention_mask(self, attention_mask: torch.Tensor, output_attentions: bool) -> torch.Tensor:
+ if output_attentions:
+ if self.config._attn_implementation == "sdpa":
+ logger.warning_once(
+ "Outputting attentions is only supported with the 'eager' attention implementation, "
+ 'not with "sdpa". Falling back to `attn_implementation="eager"`.'
+ )
+ self.config._attn_implementation = "eager"
+ elif self.config._attn_implementation != "eager":
+ logger.warning_once(
+ "Outputting attentions is only supported with the eager attention implementation, "
+ f'not with {self.config._attn_implementation}. Consider setting `attn_implementation="eager"`.'
+ " Setting `output_attentions=False`."
+ )
+
+ global_attention_mask = _prepare_4d_attention_mask(attention_mask, self.dtype)
+
+ # Create position indices
+ rows = torch.arange(global_attention_mask.shape[2]).unsqueeze(0)
+ # Calculate distance between positions
+ distance = torch.abs(rows - rows.T)
+
+ # Create sliding window mask (1 for positions within window, 0 outside)
+ window_mask = (
+ (distance <= self.config.local_attention // 2).unsqueeze(0).unsqueeze(0).to(attention_mask.device)
+ )
+ # Combine with existing mask
+ sliding_window_mask = global_attention_mask.masked_fill(window_mask.logical_not(), torch.finfo(self.dtype).min)
+
+ return global_attention_mask, sliding_window_mask
+
+
+class ModernBertPredictionHead(nn.Module):
+ def __init__(self, config: ModernBertConfig):
+ super().__init__()
+ self.config = config
+ self.dense = nn.Linear(config.hidden_size, config.hidden_size, config.classifier_bias)
+ self.act = ACT2FN[config.classifier_activation]
+ self.norm = nn.LayerNorm(config.hidden_size, eps=config.norm_eps, bias=config.norm_bias)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ return self.norm(self.act(self.dense(hidden_states)))
+
+
+@add_start_docstrings(
+ "The ModernBert Model with a decoder head on top that is used for masked language modeling.",
+ MODERNBERT_START_DOCSTRING,
+)
+class ModernBertForMaskedLM(ModernBertPreTrainedModel):
+ _tied_weights_keys = ["decoder.weight"]
+
+ def __init__(self, config: ModernBertConfig):
+ super().__init__(config)
+ self.config = config
+ self.model = ModernBertModel(config)
+ self.head = ModernBertPredictionHead(config)
+ self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=config.decoder_bias)
+
+ self.sparse_prediction = self.config.sparse_prediction
+ self.sparse_pred_ignore_index = self.config.sparse_pred_ignore_index
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_output_embeddings(self):
+ return self.decoder
+
+ def set_output_embeddings(self, new_embeddings: nn.Linear):
+ self.decoder = new_embeddings
+
+ @torch.compile(dynamic=True)
+ def compiled_head(self, output: torch.Tensor) -> torch.Tensor:
+ return self.decoder(self.head(output))
+
+ @add_start_docstrings_to_model_forward(MODERNBERT_INPUTS_DOCSTRING)
+ @add_code_sample_docstrings(
+ checkpoint=_CHECKPOINT_FOR_DOC,
+ output_type=MaskedLMOutput,
+ config_class=_CONFIG_FOR_DOC,
+ )
+ def forward(
+ self,
+ input_ids: Optional[torch.LongTensor] = None,
+ attention_mask: Optional[torch.Tensor] = None,
+ sliding_window_mask: Optional[torch.Tensor] = None,
+ position_ids: Optional[torch.Tensor] = None,
+ inputs_embeds: Optional[torch.Tensor] = None,
+ labels: Optional[torch.Tensor] = None,
+ indices: Optional[torch.Tensor] = None,
+ cu_seqlens: Optional[torch.Tensor] = None,
+ max_seqlen: Optional[int] = None,
+ batch_size: Optional[int] = None,
+ seq_len: Optional[int] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ **kwargs,
+ ) -> Union[Tuple[torch.Tensor], MaskedLMOutput]:
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+ self._maybe_set_compile()
+
+ if self.config._attn_implementation == "flash_attention_2":
+ if indices is None and cu_seqlens is None and max_seqlen is None:
+ if batch_size is None and seq_len is None:
+ if inputs_embeds is not None:
+ batch_size, seq_len = inputs_embeds.shape[:2]
+ else:
+ batch_size, seq_len = input_ids.shape[:2]
+ device = input_ids.device if input_ids is not None else inputs_embeds.device
+
+ if attention_mask is None:
+ attention_mask = torch.ones((batch_size, seq_len), device=device, dtype=torch.bool)
+
+ if inputs_embeds is None:
+ with torch.no_grad():
+ input_ids, indices, cu_seqlens, max_seqlen, position_ids, labels = _unpad_modernbert_input(
+ inputs=input_ids, attention_mask=attention_mask, position_ids=position_ids, labels=labels
+ )
+ else:
+ inputs_embeds, indices, cu_seqlens, max_seqlen, position_ids, labels = _unpad_modernbert_input(
+ inputs=inputs_embeds, attention_mask=attention_mask, position_ids=position_ids, labels=labels
+ )
+
+ outputs = self.model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ sliding_window_mask=sliding_window_mask,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ indices=indices,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ batch_size=batch_size,
+ seq_len=seq_len,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ last_hidden_state = outputs[0]
+
+ if self.sparse_prediction and labels is not None:
+ # flatten labels and output first
+ labels = labels.view(-1)
+ last_hidden_state = last_hidden_state.view(labels.shape[0], -1)
+
+ # then filter out the non-masked tokens
+ mask_tokens = labels != self.sparse_pred_ignore_index
+ last_hidden_state = last_hidden_state[mask_tokens]
+ labels = labels[mask_tokens]
+
+ logits = (
+ self.compiled_head(last_hidden_state)
+ if self.config.reference_compile
+ else self.decoder(self.head(last_hidden_state))
+ )
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(logits, labels, vocab_size=self.config.vocab_size)
+
+ if self.config._attn_implementation == "flash_attention_2":
+ with nullcontext() if self.config.repad_logits_with_grad or labels is None else torch.no_grad():
+ logits = _pad_modernbert_output(inputs=logits, indices=indices, batch=batch_size, seqlen=seq_len)
+
+ if not return_dict:
+ output = (logits,)
+ return ((loss,) + output) if loss is not None else output
+
+ return MaskedLMOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+@add_start_docstrings(
+ "The ModernBert Model with a sequence classification head on top that performs pooling.",
+ MODERNBERT_START_DOCSTRING,
+)
+class ModernBertForSequenceClassification(ModernBertPreTrainedModel):
+ def __init__(self, config: ModernBertConfig):
+ super().__init__(config)
+ self.num_labels = config.num_labels
+ self.config = config
+
+ self.model = ModernBertModel(config)
+ self.head = ModernBertPredictionHead(config)
+ self.drop = torch.nn.Dropout(config.classifier_dropout)
+ self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @add_start_docstrings_to_model_forward(MODERNBERT_INPUTS_DOCSTRING)
+ @add_code_sample_docstrings(
+ checkpoint=_CHECKPOINT_FOR_DOC,
+ output_type=SequenceClassifierOutput,
+ config_class=_CONFIG_FOR_DOC,
+ )
+ def forward(
+ self,
+ input_ids: Optional[torch.LongTensor] = None,
+ attention_mask: Optional[torch.Tensor] = None,
+ sliding_window_mask: Optional[torch.Tensor] = None,
+ position_ids: Optional[torch.Tensor] = None,
+ inputs_embeds: Optional[torch.Tensor] = None,
+ labels: Optional[torch.Tensor] = None,
+ indices: Optional[torch.Tensor] = None,
+ cu_seqlens: Optional[torch.Tensor] = None,
+ max_seqlen: Optional[int] = None,
+ batch_size: Optional[int] = None,
+ seq_len: Optional[int] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ **kwargs,
+ ) -> Union[Tuple[torch.Tensor], SequenceClassifierOutput]:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+ self._maybe_set_compile()
+
+ outputs = self.model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ sliding_window_mask=sliding_window_mask,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ indices=indices,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ batch_size=batch_size,
+ seq_len=seq_len,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ last_hidden_state = outputs[0]
+
+ if self.config.classifier_pooling == "cls":
+ last_hidden_state = last_hidden_state[:, 0]
+ elif self.config.classifier_pooling == "mean":
+ last_hidden_state = (last_hidden_state * attention_mask.unsqueeze(-1)).sum(dim=1) / attention_mask.sum(
+ dim=1, keepdim=True
+ )
+
+ pooled_output = self.head(last_hidden_state)
+ pooled_output = self.drop(pooled_output)
+ logits = self.classifier(pooled_output)
+
+ loss = None
+ if labels is not None:
+ if self.config.problem_type is None:
+ if self.num_labels == 1:
+ self.config.problem_type = "regression"
+ elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+ self.config.problem_type = "single_label_classification"
+ else:
+ self.config.problem_type = "multi_label_classification"
+
+ if self.config.problem_type == "regression":
+ loss_fct = MSELoss()
+ if self.num_labels == 1:
+ loss = loss_fct(logits.squeeze(), labels.squeeze())
+ else:
+ loss = loss_fct(logits, labels)
+ elif self.config.problem_type == "single_label_classification":
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+ elif self.config.problem_type == "multi_label_classification":
+ loss_fct = BCEWithLogitsLoss()
+ loss = loss_fct(logits, labels)
+
+ if not return_dict:
+ output = (logits,)
+ return ((loss,) + output) if loss is not None else output
+
+ return SequenceClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+@add_start_docstrings(
+ "The ModernBert Model with a token classification head on top, e.g. for Named Entity Recognition (NER) tasks.",
+ MODERNBERT_START_DOCSTRING,
+)
+class ModernBertForTokenClassification(ModernBertPreTrainedModel):
+ def __init__(self, config: ModernBertConfig):
+ super().__init__(config)
+ self.num_labels = config.num_labels
+
+ self.model = ModernBertModel(config)
+ self.head = ModernBertPredictionHead(config)
+ self.drop = torch.nn.Dropout(config.classifier_dropout)
+ self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @add_start_docstrings_to_model_forward(MODERNBERT_INPUTS_DOCSTRING)
+ @add_code_sample_docstrings(
+ checkpoint=_CHECKPOINT_FOR_DOC,
+ output_type=TokenClassifierOutput,
+ config_class=_CONFIG_FOR_DOC,
+ )
+ def forward(
+ self,
+ input_ids: Optional[torch.LongTensor] = None,
+ attention_mask: Optional[torch.Tensor] = None,
+ sliding_window_mask: Optional[torch.Tensor] = None,
+ position_ids: Optional[torch.Tensor] = None,
+ inputs_embeds: Optional[torch.Tensor] = None,
+ labels: Optional[torch.Tensor] = None,
+ indices: Optional[torch.Tensor] = None,
+ cu_seqlens: Optional[torch.Tensor] = None,
+ max_seqlen: Optional[int] = None,
+ batch_size: Optional[int] = None,
+ seq_len: Optional[int] = None,
+ output_attentions: Optional[bool] = None,
+ output_hidden_states: Optional[bool] = None,
+ return_dict: Optional[bool] = None,
+ ) -> Union[Tuple[torch.Tensor], TokenClassifierOutput]:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the token classification loss. Indices should be in `[0, ..., config.num_labels - 1]`.
+ """
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+ self._maybe_set_compile()
+
+ outputs = self.model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ sliding_window_mask=sliding_window_mask,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ indices=indices,
+ cu_seqlens=cu_seqlens,
+ max_seqlen=max_seqlen,
+ batch_size=batch_size,
+ seq_len=seq_len,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ last_hidden_state = outputs[0]
+
+ last_hidden_state = self.head(last_hidden_state)
+ last_hidden_state = self.drop(last_hidden_state)
+ logits = self.classifier(last_hidden_state)
+
+ loss = None
+ if labels is not None:
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+
+ if not return_dict:
+ output = (logits,) + outputs[1:]
+ return ((loss,) + output) if loss is not None else output
+
+ return TokenClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = [
+ "ModernBertConfig",
+ "ModernBertModel",
+ "ModernBertPreTrainedModel",
+ "ModernBertForMaskedLM",
+ "ModernBertForSequenceClassification",
+ "ModernBertForTokenClassification",
+]
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/xglm/__init__.py b/vllm/lib/python3.10/site-packages/transformers/models/xglm/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1eefd79d4cf7c3e9a24aa2f06d40f354a8fc28b2
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/xglm/__init__.py
@@ -0,0 +1,31 @@
+# Copyright 2024 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import TYPE_CHECKING
+
+from ...utils import _LazyModule
+from ...utils.import_utils import define_import_structure
+
+
+if TYPE_CHECKING:
+ from .configuration_xglm import *
+ from .modeling_flax_xglm import *
+ from .modeling_tf_xglm import *
+ from .modeling_xglm import *
+ from .tokenization_xglm import *
+ from .tokenization_xglm_fast import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/vllm/lib/python3.10/site-packages/transformers/models/xglm/configuration_xglm.py b/vllm/lib/python3.10/site-packages/transformers/models/xglm/configuration_xglm.py
new file mode 100644
index 0000000000000000000000000000000000000000..da5ded49162306551984b7ae3d7cc62319970e16
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/transformers/models/xglm/configuration_xglm.py
@@ -0,0 +1,139 @@
+# coding=utf-8
+# Copyright The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""XGLM model configuration"""
+
+from ...configuration_utils import PretrainedConfig
+from ...utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+
+class XGLMConfig(PretrainedConfig):
+ r"""
+ This is the configuration class to store the configuration of a [`XGLMModel`]. It is used to instantiate an XGLM
+ model according to the specified arguments, defining the model architecture. Instantiating a configuration with the
+ defaults will yield a similar configuration to that of the XGLM
+ [facebook/xglm-564M](https://huggingface.co/facebook/xglm-564M) architecture.
+
+ Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+ documentation from [`PretrainedConfig`] for more information.
+
+
+ Args:
+ vocab_size (`int`, *optional*, defaults to 256008):
+ Vocabulary size of the XGLM model. Defines the number of different tokens that can be represented by the
+ `inputs_ids` passed when calling [`XGLMModel`] or [`FlaxXGLMModel`].
+ max_position_embeddings (`int`, *optional*, defaults to 2048):
+ The maximum sequence length that this model might ever be used with. Typically set this to something large
+ just in case (e.g., 512 or 1024 or 2048).
+ d_model (`int`, *optional*, defaults to 1024):
+ Dimension of the layers and the pooler layer.
+ ffn_dim (`int`, *optional*, defaults to 4096):
+ Dimension of the "intermediate" (often named feed-forward) layer in decoder.
+ num_layers (`int`, *optional*, defaults to 24):
+ Number of hidden layers Transformer decoder.
+ attention_heads (`int`, *optional*, defaults to 16):
+ Number of attention heads for each attention layer in the Transformer decoder.
+ activation_function (`str` or `function`, *optional*, defaults to `"gelu"`):
+ The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
+ `"relu"`, `"silu"` and `"gelu_new"` are supported.
+ dropout (`float`, *optional*, defaults to 0.1):
+ The dropout probability for all fully connected layers in the embeddings, dencoder, and pooler.
+ attention_dropout (`float`, *optional*, defaults to 0.1):
+ The dropout ratio for the attention probabilities.
+ activation_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout ratio for activations inside the fully connected layer.
+ layerdrop (`float`, *optional*, defaults to 0.0):
+ The LayerDrop probability for the encoder. See the [LayerDrop paper](see https://arxiv.org/abs/1909.11556)
+ for more details.
+ init_std (`float`, *optional*, defaults to 0.02):
+ The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+ scale_embedding (`bool`, *optional*, defaults to `True`):
+ Scale embeddings by diving by sqrt(d_model).
+ use_cache (`bool`, *optional*, defaults to `True`):
+ Whether or not the model should return the last key/values attentions (not used by all models).
+
+ Example:
+
+ ```python
+ >>> from transformers import XGLMModel, XGLMConfig
+
+ >>> # Initializing a XGLM facebook/xglm-564M style configuration
+ >>> configuration = XGLMConfig()
+
+ >>> # Initializing a model from the facebook/xglm-564M style configuration
+ >>> model = XGLMModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "xglm"
+ keys_to_ignore_at_inference = ["past_key_values"]
+
+ attribute_map = {
+ "num_attention_heads": "attention_heads",
+ "hidden_size": "d_model",
+ "num_hidden_layers": "num_layers",
+ }
+
+ def __init__(
+ self,
+ vocab_size=256008,
+ max_position_embeddings=2048,
+ d_model=1024,
+ ffn_dim=4096,
+ num_layers=24,
+ attention_heads=16,
+ activation_function="gelu",
+ dropout=0.1,
+ attention_dropout=0.1,
+ activation_dropout=0.0,
+ layerdrop=0.0,
+ init_std=0.02,
+ scale_embedding=True,
+ use_cache=True,
+ decoder_start_token_id=2,
+ pad_token_id=1,
+ bos_token_id=0,
+ eos_token_id=2,
+ **kwargs,
+ ):
+ self.vocab_size = vocab_size
+ self.max_position_embeddings = max_position_embeddings
+ self.d_model = d_model
+ self.ffn_dim = ffn_dim
+ self.num_layers = num_layers
+ self.attention_heads = attention_heads
+ self.activation_function = activation_function
+ self.dropout = dropout
+ self.attention_dropout = attention_dropout
+ self.activation_dropout = activation_dropout
+ self.layerdrop = layerdrop
+ self.init_std = init_std
+ self.scale_embedding = scale_embedding # scale factor will be sqrt(d_model) if True
+ self.use_cache = use_cache
+
+ super().__init__(
+ pad_token_id=pad_token_id,
+ bos_token_id=bos_token_id,
+ eos_token_id=eos_token_id,
+ decoder_start_token_id=decoder_start_token_id,
+ **kwargs,
+ )
+
+
+__all__ = ["XGLMConfig"]