Jahanvi rajput patch 1

pytorch/SetFunction.py

@@ -0,0 +1,66 @@
+from typing import Set, List, Tuple
+import numpy as np
+import torch
+import torch.nn as nn
+import numpy as np
+import random
+from pytorch.optimizer.LazierThanLazyGreedyOptimizer import LazierThanLazyGreedyOptimizer
+from pytorch.optimizer.LazyGreedyOptimizer import LazyGreedyOptimizer
+from pytorch.optimizer.NaiveGreedyOptimizer import NaiveGreedyOptimizer
+from pytorch.optimizer.StochasticGreedyOptimizer import StochasticGreedyOptimizer
+
+
+class SetFunction(nn.Module):
+    def __init__(self):
+        pass
+
+    def evaluate(self, X: Set[int]) -> float:
+        return self.evaluate(X)
+
+    def evaluate_with_memoization(self, X: Set[int]) -> float:
+        return self.evaluate_with_memoization(X)
+
+    def marginal_gain(self, X: Set[int], item: int) -> float:
+        return self.marginal_gain(X, item)
+
+    def marginal_gain_with_memoization(self, X: Set[int], item: int, enable_checks: bool = True) -> float:
+       return self.marginal_gain_with_memoization(X, item)
+
+    def update_memoization(self, X: Set[int], item: int) -> None:
+        return self.update_memoization(X, item)
+
+
+    def get_effective_ground_set(self) -> Set[int]:
+        return self.get_effective_ground_set()
+
+    def maximize(self, optimizer: str, budget: float, stopIfZeroGain: bool, stopIfNegativeGain: bool, verbose: bool,
+                  costs: List[float] = None, cost_sensitive_greedy: bool = False, show_progress: bool = False, epsilon: float = 0.0) -> List[Tuple[int, float]]:
+        optimizer = self._get_optimizer(optimizer)
+        if optimizer:
+            return optimizer.maximize(self, budget, stopIfZeroGain, stopIfZeroGain, verbose, show_progress, costs, cost_sensitive_greedy)
+        else:
+            print("Invalid Optimizer")
+            return []
+
+    def _get_optimizer(self, optimizer_name: str):
+        if optimizer_name == "NaiveGreedy":
+            return NaiveGreedyOptimizer()
+        # define all optimizer classed into files
+        elif optimizer_name == "LazyGreedy":
+            return LazyGreedyOptimizer()
+        elif optimizer_name == "StochasticGreedy":
+            return StochasticGreedyOptimizer()
+        elif optimizer_name == "LazierThanLazyGreedy":
+            return LazierThanLazyGreedyOptimizer()
+        else:
+            return None
+
+    def cluster_init(self, n: int, k_dense: List[List[float]], ground: Set[int],
+                     partial: bool, lambda_: float) -> None:
+        self.cluster_init(n, k_dense, ground, partial, lambda_)
+
+    def set_memoization(self, X: Set[int]) -> None:
+        self.set_memoization(X)
+
+    def clear_memoization(self) -> None:
+        self.clear_memoization()

pytorch/__init__.py

@@ -0,0 +1,5 @@
+# /pytorch/__init__.py
+from .SetFunction import SetFunction
+
+from .optimizer import *
+from .submod import *

pytorch/optimizer/LazierThanLazyGreedyOptimizer.py

@@ -0,0 +1,120 @@
+import random
+import math
+
+class LazierThanLazyGreedyOptimizer:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def equals(val1, val2, eps):
+        return abs(val1 - val2) < eps
+
+    @staticmethod
+    def print_sorted_set(sorted_set):
+        print("[", end="")
+        for val, elem in sorted_set:
+            print(f"({val}, {elem}), ", end="")
+        print("]")
+
+    def maximize(self, f_obj, budget, stop_if_zero_gain=False, stop_if_negative_gain=False,
+                    epsilon=0.1, verbose=False, show_progress=False, costs=None, cost_sensitive_greedy=False):
+            greedy_vector = []
+            greedy_set = set()
+
+            if costs is None:
+                greedy_vector.reserve(budget)
+                greedy_set.reserve(budget)
+
+            rem_budget = budget
+            remaining_set = set(f_obj.get_effective_ground_set())
+            n = len(remaining_set)
+            epsilon = 0.05
+            random_set_size = int((n / budget) * math.log(1 / epsilon))
+
+            if verbose:
+                print(f"Epsilon = {epsilon}")
+                print(f"Random set size = {random_set_size}")
+                print("Ground set:")
+                print(remaining_set)
+                print(f"Num elements in ground set = {len(remaining_set)}")
+                print("Starting the LazierThanLazy greedy algorithm")
+                print("Initial greedy set:")
+                print(greedy_set)
+
+            f_obj.clear_memoization()
+            best_id = None
+            best_val = None
+
+            i = 0
+            step = 1
+            display_next = step
+            percent = 0
+            N = rem_budget
+            iter_count = 0
+
+            while rem_budget > 0:
+                random_set = set()
+                while len(random_set) < random_set_size:
+                    elem = random.randint(0, n - 1)
+                    if elem in remaining_set and elem not in random_set:
+                        random_set.add(elem)
+
+                if verbose:
+                    print(f"Iteration {i}")
+                    print(f"Random set = {random_set}")
+                    print("Now running lazy greedy on the random set")
+
+                candidate_id = None
+                candidate_val = None
+                new_candidate_bound = None
+
+                # Compute gains only for the elements in the remaining set
+                gains = [(f_obj.marginal_gain_with_memoization(greedy_set, elem, False), elem)
+                        for elem in remaining_set]
+
+                for j, (val, elem) in enumerate(sorted(gains, key=lambda x: (-x[0], x[1]))):
+                    if elem in random_set and elem not in greedy_set:  # Check if the element is not already selected
+                        if verbose:
+                            print(f"Checking {elem}...")
+                        candidate_id = elem
+                        candidate_val = val
+                        new_candidate_bound = f_obj.marginal_gain_with_memoization(greedy_set, candidate_id, False)
+                        if verbose:
+                            print(f"Updated gain as per updated greedy set = {new_candidate_bound}")
+                        next_elem = gains[j + 1] if j + 1 < len(gains) else None
+                        if new_candidate_bound >= next_elem[0] if next_elem else float('-inf'):
+                            if verbose:
+                                print("..better than next best upper bound, "
+                                      "selecting...")
+                            best_id = candidate_id
+                            best_val = new_candidate_bound
+                            break
+
+                if verbose:
+                    print(f"Next best item to add is {best_id} and its value addition is {best_val}")
+
+                remaining_set.remove(best_id)
+
+                if (best_val < 0 and stop_if_negative_gain) or (self.equals(best_val, 0, 1e-5) and stop_if_zero_gain):
+                    break
+                else:
+                    f_obj.update_memoization(greedy_set, best_id)
+                    greedy_set.add(best_id)
+                    greedy_vector.append((best_id, best_val))
+                    rem_budget -= 1
+
+                    if verbose:
+                        print(f"Added element {best_id} and the gain is {best_val}")
+                        print("Updated greedy set:", greedy_set)
+
+                    if show_progress:
+                        percent = int(((iter_count + 1.0) / N) * 100)
+                        if percent >= display_next:
+                            print("\r", "[" + "|" * (percent // 5) + " " * (100 // 5 - percent // 5) + "]", end="")
+                            print(f" {percent}% [Iteration {iter_count + 1} of {N}]", end="")
+                            display_next += step
+                        iter_count += 1
+
+                i += 1
+
+            return greedy_vector

pytorch/optimizer/LazyGreedyOptimizer.py

@@ -0,0 +1,97 @@
+import torch
+import heapq
+
+class LazyGreedyOptimizer:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def equals(val1, val2, eps):
+        return abs(val1 - val2) < eps
+
+    def maximize(self, f_obj, budget, stop_if_zero_gain, stop_if_negative_gain,
+                 verbose, show_progress, costs, cost_sensitive_greedy):
+        greedy_vector = []
+        greedy_set = set()
+
+        # if not costs:
+        #     greedy_vector.reserve(budget)
+        #     greedy_set.reserve(budget)
+
+        rem_budget = budget
+        ground_set = f_obj.get_effective_ground_set()
+
+        if verbose:
+            print("Ground set:")
+            print(ground_set)
+            print(f"Num elements in groundset = {len(ground_set)}")
+            print("Costs:")
+            print(costs)
+            print(f"Cost sensitive greedy: {cost_sensitive_greedy}")
+            print("Starting the lazy greedy algorithm")
+            print("Initial greedy set:")
+            print(greedy_set)
+
+        f_obj.clear_memoization()
+
+        container = []
+        heapq.heapify(container)
+        max_heap = container
+
+        if cost_sensitive_greedy:
+            for elem in ground_set:
+                gain = f_obj.marginal_gain_with_memoization(greedy_set, elem, False) / costs[elem]
+                heapq.heappush(max_heap, (-gain, elem))
+        else:
+            for elem in ground_set:
+                gain = f_obj.marginal_gain_with_memoization(greedy_set, elem, False)
+                heapq.heappush(max_heap, (-gain, elem))
+
+        if verbose:
+            print("Max heap constructed")
+
+        step = 1
+        display_next = step
+        percent = 0
+        N = rem_budget
+        iter = 0
+
+        while rem_budget > 0 and max_heap:
+            current_max = heapq.heappop(max_heap)
+            current_max_gain, current_max_elem = -current_max[0], current_max[1]
+
+            if verbose:
+                print(f"currentMax element: {current_max_elem} and its upper bound: {current_max_gain}")
+
+            new_max_bound = f_obj.marginal_gain_with_memoization(greedy_set, current_max_elem, False)
+
+            if verbose:
+                print(f"newMaxBound: {new_max_bound}")
+
+            if new_max_bound >= -max_heap[0][0]:
+                if (new_max_bound < 0 and stop_if_negative_gain) or \
+                        (self.equals(new_max_bound, 0, 1e-5) and stop_if_zero_gain):
+                    break
+                else:
+                    f_obj.update_memoization(greedy_set, current_max_elem)
+                    greedy_set.add(current_max_elem)
+                    greedy_vector.append((current_max_elem, new_max_bound))
+                    rem_budget -= 1
+
+                    if verbose:
+                        print(f"Added element {current_max_elem} and the gain is {new_max_bound}")
+                        print("Updated greedySet:", greedy_set)
+
+                    if show_progress:
+                        percent = int(((iter + 1.0) / N) * 100)
+
+                        if percent >= display_next:
+                            print(f"\r[{'|' * (percent // 5)}{' ' * (100 // 5 - percent // 5)}]",
+                                  end=f" {percent}% [Iteration {iter + 1} of {N}]")
+                            display_next += step
+
+                        iter += 1
+            else:
+                heapq.heappush(max_heap, (-new_max_bound, current_max_elem))
+
+        return greedy_vector

pytorch/optimizer/NaiveGreedyOptimizer.py

@@ -0,0 +1,90 @@
+import torch
+import random
+from typing import List, Tuple, Set
+
+class NaiveGreedyOptimizer:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def equals(val1, val2, eps):
+        return abs(val1 - val2) < eps
+
+    def maximize(
+        self, f_obj, budget, stop_if_zero_gain, stopIfNegativeGain, verbose, show_progress, costs, cost_sensitive_greedy
+    ):
+        greedy_vector = []
+        greedy_set = set()
+        if not costs:
+            # greedy_vector = [None] * budget
+            greedy_set = set()
+        rem_budget = budget
+        ground_set = f_obj.get_effective_ground_set()
+        #print(ground_set)
+        if verbose:
+            print("Ground set:")
+            print(ground_set)
+            print(f"Num elements in groundset = {len(ground_set)}")
+            print("Costs:")
+            print(costs)
+            print(f"Cost sensitive greedy: {cost_sensitive_greedy}")
+            print("Starting the naive greedy algorithm")
+            print("Initial greedy set:")
+            print(greedy_set)
+
+        f_obj.clear_memoization()
+        best_id = None
+        best_val = None
+        step = 1
+        display_next = step
+        percent = 0
+        N = rem_budget
+        iter_count = 0
+
+        while rem_budget > 0:
+            best_id = None
+            best_val = float("-inf")
+
+            for i in ground_set:
+                if i in greedy_set:
+                    continue
+                gain = f_obj.marginal_gain_with_memoization(greedy_set, i, False)
+                # print(gain)
+                if verbose:
+                    print(f"Gain of {i} is {gain}")
+
+                if gain > best_val:
+                    best_id = i
+                    best_val = gain
+
+            if verbose:
+                print(f"Next best item to add is {best_id} and its value addition is {best_val}")
+
+            if (best_val < 0 and stopIfNegativeGain) or (
+                self.equals(best_val, 0, 1e-5) and stop_if_zero_gain
+            ):
+                break
+            else:
+                f_obj.update_memoization(greedy_set, best_id)
+                greedy_set.add(best_id)
+                greedy_vector.append((best_id, best_val))
+                rem_budget -= 1
+
+                if verbose:
+                    print(f"Added element {best_id} and the gain is {best_val}")
+                    print(f"Updated greedy set: {greedy_set}")
+
+                if show_progress:
+                    percent = int((iter_count + 1.0) / N * 100)
+
+                    if percent >= display_next:
+                        print(
+                            f"\r[{'|' * (percent // 5)}{' ' * (100 // 5 - percent // 5)}]",
+                            end="",
+                        )
+                        print(f"{percent}% [Iteration {iter_count + 1} of {N}]", end="")
+                        display_next += step
+
+                    iter_count += 1
+
+        return greedy_vector