Code reformat using black

Author: aldro61

examples/decision_boundary.py

@@ -23,10 +23,22 @@
 from sklearn.naive_bayes import GaussianNB
 from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
 
-h = .02  # step size in the mesh
-
-names = ["Nearest Neighbors", "Linear SVM", "RBF SVM", "Gaussian Process", "Neural Net", "Naive Bayes", "QDA",
-         "Decision Tree", "Random Forest", "AdaBoost", "SCM-Conjunction", "SCM-Disjunction"]
+h = 0.02  # step size in the mesh
+
+names = [
+    "Nearest Neighbors",
+    "Linear SVM",
+    "RBF SVM",
+    "Gaussian Process",
+    "Neural Net",
+    "Naive Bayes",
+    "QDA",
+    "Decision Tree",
+    "Random Forest",
+    "AdaBoost",
+    "SCM-Conjunction",
+    "SCM-Disjunction",
+]
 
 classifiers = [
     KNeighborsClassifier(3),
@@ -40,17 +52,21 @@
     RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1),
     AdaBoostClassifier(),
     SetCoveringMachineClassifier(max_rules=4, model_type="conjunction", p=2.0),
-    SetCoveringMachineClassifier(max_rules=4, model_type="disjunction", p=1.0)]
+    SetCoveringMachineClassifier(max_rules=4, model_type="disjunction", p=1.0),
+]
 
-X, y = make_classification(n_features=2, n_redundant=0, n_informative=2,
-                           random_state=1, n_clusters_per_class=1)
+X, y = make_classification(
+    n_features=2, n_redundant=0, n_informative=2, random_state=1, n_clusters_per_class=1
+)
 rng = np.random.RandomState(2)
 X += 2 * rng.uniform(size=X.shape)
 linearly_separable = (X, y)
 
-datasets = [make_moons(noise=0.3, random_state=0),
-            make_circles(noise=0.2, factor=0.5, random_state=1),
-            linearly_separable]
+datasets = [
+    make_moons(noise=0.3, random_state=0),
+    make_circles(noise=0.2, factor=0.5, random_state=1),
+    linearly_separable,
+]
 
 figure = plt.figure(figsize=(27, 11))
 i = 1
@@ -59,21 +75,21 @@
     # preprocess dataset, split into training and test part
     X, y = ds
     X = StandardScaler().fit_transform(X)
-    X_train, X_test, y_train, y_test = \
-        train_test_split(X, y, test_size=.4, random_state=42)
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.4, random_state=42
+    )
 
-    x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
-    y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
-    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
-                         np.arange(y_min, y_max, h))
+    x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
+    y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
+    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
 
     # just plot the dataset first
     cm = plt.cm.RdBu
-    cm_bright = ListedColormap(['#FF0000', '#0000FF'])
-    #cm = plt.cm.PiYG
-    #cm_bright = ListedColormap(['#FF0000', '#00FF00'])
-    #cm = plt.cm.bwr
-    #cm_bright = ListedColormap(['#0000FF', '#FF0000'])
+    cm_bright = ListedColormap(["#FF0000", "#0000FF"])
+    # cm = plt.cm.PiYG
+    # cm_bright = ListedColormap(['#FF0000', '#00FF00'])
+    # cm = plt.cm.bwr
+    # cm_bright = ListedColormap(['#0000FF', '#FF0000'])
     ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
     if ds_cnt == 0:
         ax.set_title("Input data")
@@ -120,25 +136,36 @@
 
         # Put the result into a color plot
         Z = Z.reshape(xx.shape)
-        ax.contourf(xx, yy, Z, cmap=cm, alpha=.8)
+        ax.contourf(xx, yy, Z, cmap=cm, alpha=0.8)
 
         # Plot also the training points
         ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright)
         # and testing points
-        ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright,
-                   alpha=0.6)
+        ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6)
 
         ax.set_xlim(xx.min(), xx.max())
         ax.set_ylim(yy.min(), yy.max())
         ax.set_xticks(())
         ax.set_yticks(())
         if ds_cnt == 0:
             ax.set_title(name.title())
-        ax.text(xx.min() + 0.2, yy.min() + 0.2, 'Acc.: {0:.2f}'.format(score).lstrip('0'), size=15,
-                horizontalalignment='left', bbox=dict(facecolor='white', edgecolor='black', alpha=0.8))
-        ax.text(xx.min() + 0.2, yy.min() + 0.8, "Rules: {0!s}".format(n_rules) if n_rules is not None else "",
-                size=15, horizontalalignment='left', bbox=dict(facecolor='white', edgecolor='black', alpha=0.8))
+        ax.text(
+            xx.min() + 0.2,
+            yy.min() + 0.2,
+            "Acc.: {0:.2f}".format(score).lstrip("0"),
+            size=15,
+            horizontalalignment="left",
+            bbox=dict(facecolor="white", edgecolor="black", alpha=0.8),
+        )
+        ax.text(
+            xx.min() + 0.2,
+            yy.min() + 0.8,
+            "Rules: {0!s}".format(n_rules) if n_rules is not None else "",
+            size=15,
+            horizontalalignment="left",
+            bbox=dict(facecolor="white", edgecolor="black", alpha=0.8),
+        )
         i += 1
 
 plt.tight_layout()
-plt.savefig("decision_boundary.pdf", bbox_inches="tight")
+plt.savefig("decision_boundary.pdf", bbox_inches="tight")

examples/sklearn_compatibility.py

@@ -10,25 +10,29 @@
 n_examples = 200
 n_features = 1000
 
-X,y = make_classification(n_samples=n_examples, n_features=n_features, n_classes=2, 
-                          random_state=np.random.RandomState(42))
+X, y = make_classification(
+    n_samples=n_examples,
+    n_features=n_features,
+    n_classes=2,
+    random_state=np.random.RandomState(42),
+)
 
 params = {
-    "p" : [0.5,1.,2.],
-    "max_rules" : [1,2,3,4,5],
-    "model_type" : ["conjunction","disjunction"]
+    "p": [0.5, 1.0, 2.0],
+    "max_rules": [1, 2, 3, 4, 5],
+    "model_type": ["conjunction", "disjunction"],
 }
 clf = SetCoveringMachineClassifier(random_state=np.random.RandomState(42))
 
 print("Fitting in GirdSearchCV...")
 
 grid = GridSearchCV(estimator=clf, param_grid=params, cv=3, n_jobs=-1, verbose=True)
-grid.fit(X,y)
+grid.fit(X, y)
 
 print("GridSearch passed!")
 print("Fitting in pipeline with StandardScaler...")
 
-clf = Pipeline([("scaler",StandardScaler()),("scm",SetCoveringMachineClassifier())])
-clf.fit(X,y)
+clf = Pipeline([("scaler", StandardScaler()), ("scm", SetCoveringMachineClassifier())])
+clf.fit(X, y)
 
 print("Done without error.")

examples/tiebreaker.py

@@ -11,12 +11,22 @@
 n_examples = 200
 n_features = 1000
 
-X,y = make_classification(n_samples=n_examples, n_features=n_features, n_classes=2,
-                          random_state=np.random.RandomState(42))
+X, y = make_classification(
+    n_samples=n_examples,
+    n_features=n_features,
+    n_classes=2,
+    random_state=np.random.RandomState(42),
+)
+
 
 def my_tiebreaker(model_type, feature_idx, thresholds, kind):
-    print("Hello from the tiebreaker! Got {0:d} equivalent rules for this {1!s} model.".format(len(feature_idx), model_type))
+    print(
+        "Hello from the tiebreaker! Got {0:d} equivalent rules for this {1!s} model.".format(
+            len(feature_idx), model_type
+        )
+    )
     return 0
 
+
 clf = SetCoveringMachineClassifier()
 clf.fit(X, y, tiebreaker=my_tiebreaker)

examples/training_time.py

@@ -15,15 +15,21 @@ def increase_n_features():
     n_bench_points = 5
     n_examples = 1000
     n_features = 100000
-    
+
     avg_times = np.zeros(n_bench_points)
     nfs = [int(n_features * p) for p in np.linspace(0.01, 1.0, n_bench_points)]
     for _ in range(n_repeats):
         times = []
         for nf in nfs:
-            X, y = make_classification(n_samples=n_examples, n_features=nf, n_classes=2,
-                                       random_state=np.random.RandomState(42))
-            clf = SetCoveringMachineClassifier(model_type="conjunction", p=1.0, max_rules=100)
+            X, y = make_classification(
+                n_samples=n_examples,
+                n_features=nf,
+                n_classes=2,
+                random_state=np.random.RandomState(42),
+            )
+            clf = SetCoveringMachineClassifier(
+                model_type="conjunction", p=1.0, max_rules=100
+            )
             t = time()
             clf.fit(X, y)
             times.append(time() - t)
@@ -34,7 +40,11 @@ def increase_n_features():
     plt.plot(nfs, avg_times)
     plt.xlabel("n features")
     plt.ylabel("time (seconds)")
-    plt.title("Training time for {0:d} <= n <= {1:d} features ({2:d} examples)".format(min(nfs), max(nfs), n_examples))
+    plt.title(
+        "Training time for {0:d} <= n <= {1:d} features ({2:d} examples)".format(
+            min(nfs), max(nfs), n_examples
+        )
+    )
     plt.savefig("n_features.png", bbox_inches="tight")
 
 
@@ -43,15 +53,21 @@ def increase_n_examples():
     n_bench_points = 5
     n_examples = 10000
     n_features = 1000
-    
+
     avg_times = np.zeros(n_bench_points)
     n_exs = [int(n_examples * p) for p in np.linspace(0.01, 1.0, n_bench_points)]
     for _ in range(n_repeats):
         times = []
         for n_ex in n_exs:
-            X, y = make_classification(n_samples=n_ex, n_features=n_features, n_classes=2,
-                                       random_state=np.random.RandomState(42))
-            clf = SetCoveringMachineClassifier(model_type="conjunction", p=1.0, max_rules=100)
+            X, y = make_classification(
+                n_samples=n_ex,
+                n_features=n_features,
+                n_classes=2,
+                random_state=np.random.RandomState(42),
+            )
+            clf = SetCoveringMachineClassifier(
+                model_type="conjunction", p=1.0, max_rules=100
+            )
             t = time()
             clf.fit(X, y)
             times.append(time() - t)
@@ -62,12 +78,18 @@ def increase_n_examples():
     plt.plot(n_exs, avg_times)
     plt.xlabel("n examples")
     plt.ylabel("time (seconds)")
-    plt.title("Training time for {0:d} <= n <= {1:d} examples ({2:d} features)".format(min(n_exs), max(n_exs), n_features))
+    plt.title(
+        "Training time for {0:d} <= n <= {1:d} examples ({2:d} features)".format(
+            min(n_exs), max(n_exs), n_features
+        )
+    )
     plt.savefig("n_examples.png", bbox_inches="tight")
 
 
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.DEBUG,
-                        format="%(asctime)s.%(msecs)d %(levelname)s %(module)s - %(funcName)s: %(message)s")
+if __name__ == "__main__":
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format="%(asctime)s.%(msecs)d %(levelname)s %(module)s - %(funcName)s: %(message)s",
+    )
     increase_n_examples()
     increase_n_features()

pyscm/__init__.py

@@ -16,4 +16,4 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-from .scm import SetCoveringMachineClassifier
+from .scm import SetCoveringMachineClassifier

pyscm/model.py

@@ -62,6 +62,7 @@ def __len__(self):
     def __str__(self):
         return self._to_string()
 
+
 class ConjunctionModel(BaseModel):
     def predict(self, X):
         predictions = np.ones(X.shape[0], np.bool)

pyscm/rules.py

@@ -26,6 +26,7 @@ class BaseRule(object):
     A rule mixin class
 
     """
+
     def __init__(self):
         super(BaseRule, self).__init__()
 
@@ -79,6 +80,7 @@ class DecisionStump(BaseRule):
         The case in which the rule returns 1, either "greater" or "less_equal".
 
     """
+
     def __init__(self, feature_idx, threshold, kind="greater"):
         self.feature_idx = feature_idx
         self.threshold = threshold
@@ -116,8 +118,13 @@ def inverse(self):
             A rule that is the inverse of self.
 
         """
-        return DecisionStump(feature_idx=self.feature_idx, threshold=self.threshold,
-                             kind="greater" if self.kind == "less_equal" else "less_equal")
+        return DecisionStump(
+            feature_idx=self.feature_idx,
+            threshold=self.threshold,
+            kind="greater" if self.kind == "less_equal" else "less_equal",
+        )
 
     def __str__(self):
-        return "X[{0:d}] {1!s} {2:.3f}".format(self.feature_idx, ">" if self.kind == "greater" else "<=", self.threshold)
+        return "X[{0:d}] {1!s} {2:.3f}".format(
+            self.feature_idx, ">" if self.kind == "greater" else "<=", self.threshold
+        )