Merge pull request #2 from nivmoti/master

Adding visualizations to convex optimization problems, from the cvxpy library

Author: SteveDiamond

.gitignore

@@ -127,3 +127,4 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+.idea/

README.md

@@ -12,3 +12,104 @@ from analyzer import tech_support
 # Analyze the problem.
 tech_support(problem)
 ```
+
+
+# Visual:
+The Purpose of our project is to visualize the Problem expressions which can be found in CVXPY library. <br /> 
+During the development process, we have created four different functions that allow to visualize the Problem expressions in a more accessible and clear way for library users. <br />
+As you can see in the file:  ``examples.py`` <br />
+You can see several examples of how to run expressions using the different functions we created.
+
+## v.draw_graph(xmin, xmax):
+A function that graphically displays all the solutions of a specific expression where the variable is represented as X and the equation as Y.
+If a function is called without any arguments, the default value will be xmin=-10 xmax=10.
+
+Here you can see the results:
+As you can see for the phrase: `Minimize(-1 * (y2) ** 2 + 2 * y2)` <br />
+with the constraints `[y2 >= 1]` <br />
+
+```
+
+    y2 = Variable()
+    
+    objective = Minimize(-1 * (y2) ** 2 + 2 * y2)
+    constraints = [y2 >= 1]
+    v = Visual(objective)
+    print(v.expr)
+    v.draw_graph()
+```
+by running `v.draw_graph()` you will get the following graph:<br />
+![3](https://user-images.githubusercontent.com/93201414/229357160-6517dcca-fcb7-4257-b145-400c084bf853.png)
+
+It displays all the solutions of the equation that we want to see when substituting variable values between -10 to 10.
+
+## v.show_and_save(file_name):
+We created this function to enable viewing the expression in a graph format with nodes, which will allow for visual and clear representation. <br />
+For each expression you choose, the function's output is a PDF file named "file_name.pdf", which is very similar to the DCP Analyzer. https://dcp.stanford.edu/analyzer <br />
+
+Here too it was important for us to present for all: Parameters , Variables <br />
+Which `Sing` is of a type of `Positive` , `Negative`, `Unknown` and Which `Curvature` is of a type of `Constant`,`Affine`,`Convex`,`Concave`,`Unknown`. <br />
+
+In the ``example.py`` file you can run several expressions on this function.
+
+```
+    x2 = Variable()
+    y2 = Variable()
+    objective1 = Minimize((x2 - y2) ** 2)
+    v = Visual(objective1)
+    v.show_and_save("file_name")
+```
+
+Minimize((x2 - y2) ** 2) <br />
+
+You will get the following graph: <br />
+
+<img width="300" alt="4" src="https://user-images.githubusercontent.com/93201414/229358362-0c92af7f-3ebc-4dd5-85d1-46b82e1aafcd.PNG">
+<br />
+
+**Please note that you can run only one example at a time and not all of them together. If you run all of them together, the output file will show only the graph of the last example that was executed** <br />
+
+
+## v.print_expr():
+This function prints the expression in the structure of a tree in the RUN window.
+
+```
+    x2 = Variable()
+    y2 = Variable()
+    
+    objective1 = Minimize((x2 - y2) ** 2)
+    
+    # examples for print_tree:
+
+    print("---objective 1 ---")
+    v = Visual(objective1)
+    print(v.curvature_sign_list)
+    print("---objective 1 ---")
+
+    v.print_expr()
+```
+For each expression, you can run the following function,<br />
+This will produce a graph that will be displayed in the runtime window.
+
+For example **for the first expression** 
+1. Minimize((x2 - y2) ** 2) <br />
+
+you will get : 
+![image](https://user-images.githubusercontent.com/93201414/229359112-bc30b68a-bcd8-4739-b302-0d96932c2b8f.png)
+
+## v.show():
+The function uses the library tkinter <br />
+The output shows the tree in a way that opens and closes according to the user <br />
+Unlike show_and_save() the output is not saved but opens in a pop-up window <br />
+
+```
+    x2 = Variable()
+    y2 = Variable()
+    objective1 = Minimize((x2 - y2) ** 2)
+    v = Visual(objective1)
+    v.show()
+```
+
+<img width="158" alt="two" src="https://user-images.githubusercontent.com/93201414/237039372-d6d79c0c-d564-467d-ba21-b5290e7873ba.PNG">
+
+

analyzer/solvers.py

@@ -13,6 +13,8 @@
 from cvxpy.error import DCPError
 import cvxpy as cp
 
+from visual.visual_expression import prob
+
 
 def get_solvers(problem):
     """Get valid solvers.

analyzer/version.py

@@ -27,3 +27,6 @@ def check_version():
     else:
         msg = "The request to pypi returned status code" + str(r.status_code)
         raise RuntimeError(msg)
+
+
+check_version()

requirements.txt

@@ -0,0 +1,11 @@
+cvxpy~=1.3.0
+numpy~=1.24.2
+future~=0.18.3
+cvxopt~=1.3.0
+requests~=2.28.2
+setuptools~=57.0.0
+matplotlib~=3.7.1
+graphviz~=0.20.1
+cp~=2020.12.3
+sympy~=1.11.1
+pytest~=7.3.1

tests/test_basics.py

@@ -26,3 +26,8 @@ def test_solvers():
     prob = cp.Problem(cp.Minimize(cp.sum_squares(x)), [-1 <= x, x <= 1])
     solvers = get_solvers(prob)
     assert len(solvers) > 0
+
+
+test_solvers()
+test_checker()
+test_version()

visual/examples.py

@@ -0,0 +1,47 @@
+import cvxpy as cp
+import cvxopt
+from cvxpy import Minimize, Variable, quad_form
+from visual.visual_expression import Visual
+
+if __name__ == '__main__':
+    n = 3
+    P = cvxopt.matrix([13, 12, -2,
+                       12, 17, 6,
+                       -2, 6, 12], (n, n))
+    q = cvxopt.matrix([-22, -14.5, 13], (n, 1))
+    r = 1
+    x_star = cvxopt.matrix([1, 1 / 2, -1], (n, 1))
+
+    x1 = Variable(n)
+    y1 = Variable()
+    x2 = Variable()
+    y2 = Variable()
+    z1 = Variable(n)
+
+    objective = Minimize(-1 * y2 ** 2 + 2 * y2)
+    objective1 = Minimize((x2 - y2) ** 2)
+    objective2 = Minimize(0.5 * quad_form(x1, P) - cp.sum_squares(x1) + q.T @ x1 + r + y1)
+
+    print("----objective----")
+    v = Visual(objective)
+    v.show()
+    v.show_and_save("file_name")
+    v.draw_graph()
+    v.print_expr()
+    print("----objective----")
+
+    print("----objective1----")
+    v = Visual(objective1)
+    v.show()
+    v.show_and_save("file_name1")
+    v.draw_graph()
+    v.print_expr()
+    print("----objective1----")
+
+    print("----objective2----")
+    v = Visual(objective2)
+    v.show()
+    v.show_and_save("file_name2")
+    v.draw_graph()
+    v.print_expr()
+    print("----objective2----")

visual/expression_tree.py

@@ -0,0 +1,134 @@
+import re
+
+
+class Node:
+    # Each node has a unique name because an operator can appear more than once
+    uniqNameForTree = 0
+    count_curvature = 0
+    count_sign = 0
+
+    def __init__(self, node, expr: str, flag=0):
+        # The father of this node - for every operator the father is of type expression
+        # and for every expression the father is of type operator
+        self.father = node
+        # A list of the children of the node -
+        # each expression has a single child (the operator with the highest priority)
+        # and each operator has several children
+        self.sons = []
+        # the value of the node
+        self.expr = expr
+        # flag = 1 ->operator , flag = 0 ->expression
+        self.flag = flag
+        self.name = self.uniqNameForTree
+        Node.uniqNameForTree += 1
+        self.curvature = None
+        self.sign = None
+
+        self.c_curvature = self.count_curvature
+        Node.count_curvature += 1
+
+        self.c_sign = self.count_sign
+        Node.count_sign += 1
+
+    # ---for test---
+    def checkin_sons(self, expr: str):
+        for s in self.sons:
+            expression = expr.split(' ')
+            bool = True
+            for e in expression:
+                if not s.expr.__contains__(e):
+                    bool = False
+                    break
+            if bool:
+                return True
+        return False
+
+    def node_son(self, expr: str):
+        if not self.sons:
+            return None
+        for s in self.sons:
+            if s.expr == expr:
+                return s
+        return None
+
+    # ---for test---
+
+    def insert(self, op: str):
+        """
+        This function get an operator and uses it to split the expression and create new nodes
+
+        """
+        # create a new node of type operator
+        if op not in self.expr:
+            return
+        node = Node(self, op, 1)
+        self.sons.append(node)
+        # We will look for the first position of the operator that is not inside parentheses and inside a matrix
+        count = -1
+        check1 = False
+        check2 = False
+        for i in self.expr:
+            count += 1
+            if i == '[':
+                check2 = True
+                continue
+            if i == ']':
+                check2 = False
+                continue
+            if i == '(':
+                check1 = True
+                continue
+            if i == ')':
+                check1 = False
+                continue
+            if i == op and not check1 and not check2:
+                break
+
+        ans = [self.expr[:count], self.expr[count + 1:]]
+        for i in range(len(ans)):
+            node.sons.append(Node(node, ans[i], 0))
+
+    def insert_func(self, op: str):
+        """
+          This function inserts a function type operator and
+          this means that the expression should be split according to the number of parameters the function accepts
+        """
+        index_first = op.index('(')
+        index_sec = op.rfind(')')
+        newExpr = op[index_first + 1: index_sec]
+        # the operator is the name of the function
+        node = Node(self, op.split('(')[0], 1)
+        self.sons.append(node)
+        param = re.split(r',(?![^()]*\))', newExpr)
+        # The children of a function type operator are the parameters it accepts
+        for p in param:
+            node.sons.append(Node(node, p, 0))
+
+    def print_tree(self, spaces=0, counter=0):
+        """
+        This function prints the tree recursively
+        """
+        for i in range(spaces):
+            print("   ", end="")
+        if self.flag == 0:
+            # Print the child's number
+            print(counter, ".expression:", self.expr)
+            s = spaces + 1
+            c = 1
+            for e in self.sons:
+                e.print_tree(s, c)
+                c += 1
+                for i in range(spaces + 1):
+                    print("   ", end="")
+                print("]")
+        else:
+            print("operator:", self.expr)
+            for i in range(spaces):
+                print("   ", end="")
+            print("[")
+            s = spaces + 1
+            c = 1
+            for e in self.sons:
+                e.print_tree(s, c)
+                c += 1
+        s += 1