initial commit

README.md

@@ -1,8 +1,8 @@
 ---
-title: Integer Programming
-emoji: ⚡
-colorFrom: purple
-colorTo: gray
+title: Google Sheet Extractor
+emoji: 👀
+colorFrom: blue
+colorTo: yellow
 sdk: gradio
 sdk_version: 3.43.2
 app_file: app.py
@@ -10,4 +10,11 @@ pinned: false
 license: mit
 ---
 
+## Getting Started
+
+Please configure your OpenAI API key as an environment variable:
+```
+export OPENAI_API_KEY="yout-key-here"
+```
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,4 @@
+from transformers.tools.base import launch_gradio_demo
+from integer_programming import IntegerProgrammingTool
+
+launch_gradio_demo(IntegerProgrammingTool)

integer_programming.py

@@ -0,0 +1,135 @@
+import math
+import json
+import regex
+import inspect
+import guidance
+from ast import literal_eval
+from transformers import Tool
+from ortools.linear_solver import pywraplp
+
+guidance.llm = guidance.llms.OpenAI("gpt-4")
+
+structure_program = guidance(
+'''
+{{#user~}}
+{{description}}
+Help me extract args from the data blob to apply the following algorithm:
+{{code}}
+
+----
+
+{{~#each examples}}
+Data Blob: {{this.input}}
+Result: {{this.output}}
+---
+{{~/each}}
+
+Please help me extract the input values from a given data blob into a JSON.
+Data Blob: {{data_blob}}
+Result: 
+{{~/user}}
+
+{{#assistant~}}
+{{gen 'output'}}
+{{~/assistant}}
+''')
+
+class IntegerProgrammingTool(Tool):
+    name = "integer_programming_tool"
+    description = """
+    This tool solves an integer programming problem.
+    Input is data_blob
+    Output is the optimal solution as a string.
+    """
+    inputs = ["text"]
+    outputs = ["text"]
+    examples = [
+        {'input': '''
+        ,Space,Price
+        Puzzle,1,2
+        BoardGame,5,12
+
+        Constraint,100
+        ''',
+        'output': {
+            "objective_coeffs": [
+                [1, 2],
+                [5, 15],
+            ],
+            "constraints": [100],
+            "bounds": [
+                [0, None],
+                [0, None]
+            ],
+            "goal": "max"
+          },
+        },
+        {'input': '''
+        ,Space,Price
+        Puzzle,3,12
+        BoardGame,15,120
+
+        Constraint,300
+        ''',
+        'output': {
+            "objective_coeffs": [
+                [3, 2],
+                [15, 120],
+            ],
+            "constraints": [300],
+            "bounds": [
+                [0, None],
+                [0, None]
+            ],
+            "goal": "max"
+          },
+        },
+    ]
+    def __call__(self, data_blob):
+        code = inspect.getsourcelines(self.__call__)
+        args = structure_program(
+            description=self.description,
+            code=code,
+            examples=self.examples,
+            data_blob=data_blob,
+        )['output']
+        pattern = regex.compile(r"\{(?:[^{}]|(?R))*\}")
+        matches = pattern.findall(args)[0]
+        args = literal_eval(matches)
+        print(args)
+        objective_coeffs = args['objective_coeffs']
+        constraints = args['constraints']
+        bounds = args['bounds']
+        goal = args['goal']
+
+        objective_coeffs = list(zip(*objective_coeffs))
+        solver = pywraplp.Solver.CreateSolver("CBC")
+        variables = [solver.IntVar(
+        int(bounds[i][0]) if bounds[i][0] is not None else -math.inf,
+        int(bounds[i][1]) if bounds[i][1] is not None else math.inf,
+        f"x{i}") for i in range(len(objective_coeffs))]
+
+        # Set objective function
+        objective = solver.Objective()
+        for i, coeff_list in enumerate(objective_coeffs):
+            for j, coeff_value in enumerate(coeff_list):
+                objective.SetCoefficient(variables[j], coeff_value)
+        if goal == 'max':
+            objective.SetMaximization()
+        else:
+            objective.SetMinimization()
+
+        # Add constraints
+        for i, constraint_value in enumerate(constraints):
+            if constraint_value:
+                constraint = solver.RowConstraint(0, constraint_value)
+                for j, coeff in enumerate(objective_coeffs[i]):
+                    constraint.SetCoefficient(variables[j], coeff)
+        
+        solver.Solve()
+        
+        solution = {"Objective value": objective.Value()}
+        for i, variable in enumerate(variables):
+            solution[f"x{i}"] = variable.solution_value()
+        
+        return json.dumps(solution)

requirements.txt

@@ -0,0 +1,6 @@
+openai
+ortools
+requests
+guidance
+huggingface_hub
+transformers

tool_config.json

@@ -0,0 +1,6 @@
+{
+  "description": "This tool solves an integer programming problem. Input is data_blob. Output is the optimal solution.",
+  "name": "integer_programming_tool",
+  "tool_class": "integer_programming.IntegerProgrammingTool"
+}
+