Metadata-Version: 2.1
Name: tf_osqp
Version: 0.1.0
Summary: Tensorflow implementation of OSQP solver (unofficial)
Home-page: https://github.com/rishabhjha33/tf-osqp
Author: Rishabh Jha
Author-email: rishabhjha.code@gmail.com
Maintainer: Rishabh Jha
Maintainer-email: rishabhjha.code@gmail.com
License: Apache 2.0
Description: ## TF-OSQP
        
        [![TF](https://aleen42.github.io/badges/src/tensorflow.svg)](https://www.tensorflow.org/) [![PEP8](https://img.shields.io/badge/code%20style-pep8-orange.svg)](https://www.python.org/dev/peps/pep-0008/) [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
        
        
        Tensorflow 2.x implementation of [OSQP](https://osqp.org/).  
        
        **This is not an official OSQP implementation.** You can find official versions [here](https://github.com/oxfordcontrol/osqp).
        
        From their page: 
        
        The OSQP (Operator Splitting Quadratic Program) solver is a numerical
        optimization package for solving problems in the form
        
            minimize        0.5 x' P x + q' x
        
            subject to      l <= A x <= u
        
        where ``x in R^n`` is the optimization variable. The objective function
        is defined by a positive semidefinite matrix ``P in S^n_+`` and vector
        ``q in R^n``. The linear constraints are defined by matrix
        ``A in R^{m x n}`` and vectors ``l in R^m U {-inf}^m``,
        ``u in R^m U {+inf}^m``.
        
        
        
        ## Motivation
        This project was created as a complement to a new TF2 implementation for the Revised Greedy Expansion algorithm used to find the convex hull of high dimensional vectors. Locating the distance of a point from a convex hull requires the solution of linearly constrained quadratic equations.
        
        Code for that project will be made available soon.
        
        
        ## Features
        
        ### Live in latest release
        **Full TF 2.x compatibility:** All computations use native TF ops
        
        **Python side effects absent:** Every constant and variable coded as named instances of ```tf.constant``` and ```tf.Variable```
        
        **Well documented:** Docstrings available for all function with constraints and meanings explained for parameters
        
        ### Future releases
        **Graph mode execution:** Leverage tf.function() to execute code in Graph mode on TF2
        
        **Training parameter assignment:** Ability to modify training parameters extended to every single parameter
        
        **Full OSQP feature set:** Remaining features like solution polishing added
        
        
        ## Dependencies
        
        | Dependency   | Description | Version   | License
        | ------------- |:-------------:| :----:|:---:|
        | TensorFlow  | Open source symbolic math library for ML    | >= 2.4rc3 | Apache 2.0 
        | python      | Base python software | >= 3.6      | PSF
        | numpy | Used to define nan and inf constants | >= 1.18      | NumPy License
        
        
        ## Installation
        
        #### Latest PyPI release
        
        	pip install tf_osqp
        
        
        ## Usage
        
        Having defined ```tf.float32``` matrices P, q, A, l, u, use the code as follows:
        
        	from tf_osqp.tf_osqp import solver
        	
            quad_solver = solver()
            quad_solver.set_problem(P, q, A, l, u)
            
            x, y = quad_solver.solve()
        
        Here, x will be the solution at optima, y will be the corresponding Lagrangian
        
        
        ## Contribute
        
        ### Product backlog
        Current implementation is the skeletal engine written to get the work done. It is some way away from full potential.  
        - Refactor code to tf.function() to capitalize on speedups from Graph execution
        	- Current version uses Eager execution. This constrains performance and speeds are similar to numpy implementation   
        - Add remaining OSQP functionality, e.g., solution polishing
        - Make API freer to use, including option for warm starts and changing training parameters between iterations
        
        ### Code style
        
        Code is written with PEP-8 guidelines - recommended for PRs.
        
        ## Citations
        
        1. G. Banjac, P. Goulart, B. Stellato, and S. Boyd, Infeasibility detection in the alternating direction method of multipliers for convex optimization, Journal of Optimization Theory and Applications 183(2019), no. 2, 490–519. 
        2. G. Banjac, B. Stellato, N. Moehle, P. Goulart, A. Bemporad, and S. Boyd, Embedded codegeneration using the OSQP solver, IEEE Conference on Decision and Control (CDC), 2017. 
        3. M. Schubiger, G. Banjac, and J. Lygeros, GPU acceleration of ADMM for large-scale quadratic programming, Journal of Parallel and Distributed Computing 144(2020), 55–67.
        4. B. Stellato, G. Banjac, P. Goulart, A. Bemporad, and S. Boyd, OSQP: an operator splitting solver for quadratic programs, Mathematical Programming Computation 12(2020), no. 4,637–672.
        5. B. Stellato, V. V. Naik, A. Bemporad, P. Goulart, and S. Boyd, Embedded mixed-integer quadratic optimization using the OSQP solver, European Control Conference (ECC), 2018
        
        The original pure python source code for OSQP can be found on their repo [here](https://github.com/oxfordcontrol/osqp-python/tree/master/modulepurepy).
        
        Current implementation in this repo can execute on GPUs but the code hasn't been optimized to offer large speed ups yet. To see better performance on GPUs, the recommendation is to OSQP's recommended CUDA implementation: [cuosqp](https://github.com/oxfordcontrol/cuosqp) 
        
        ## License
        Apache 2.0 
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Development Status :: 3 - Alpha
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Operating System :: OS Independent
Classifier: Intended Audience :: Science/Research
Classifier: Natural Language :: English
Requires-Python: >=3.5
Description-Content-Type: text/markdown
