Adding scripts + data

classification/Bioresponse/label.json

@@ -0,0 +1,4 @@
+{
+	"0": "0",
+	"1": "1"
+}

classification/Bioresponse/rules.json

@@ -0,0 +1,472 @@
+{
+    "rules": [
+        {
+            "rule": [
+                [
+                    740,
+                    0.054,
+                    false
+                ],
+                [
+                    218,
+                    0.663,
+                    false
+                ],
+                [
+                    1271,
+                    0.5,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 100.0,
+            "support": 2
+        },
+        {
+            "rule": [
+                [
+                    85,
+                    0.166,
+                    false
+                ],
+                [
+                    1722,
+                    0.5,
+                    true
+                ],
+                [
+                    102,
+                    0.255,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 75.0,
+            "support": 5
+        },
+        {
+            "rule": [
+                [
+                    4,
+                    0.162,
+                    false
+                ],
+                [
+                    194,
+                    0.737,
+                    false
+                ],
+                [
+                    14,
+                    0.558,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 66.67,
+            "support": 8
+        },
+        {
+            "rule": [
+                [
+                    597,
+                    0.125,
+                    true
+                ],
+                [
+                    700,
+                    0.033,
+                    true
+                ],
+                [
+                    1340,
+                    0.5,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 75.0,
+            "support": 29
+        },
+        {
+            "rule": [
+                [
+                    450,
+                    0.083,
+                    true
+                ],
+                [
+                    1108,
+                    0.5,
+                    true
+                ],
+                [
+                    82,
+                    0.389,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 77.27,
+            "support": 27
+        },
+        {
+            "rule": [
+                [
+                    98,
+                    0.707,
+                    true
+                ],
+                [
+                    1366,
+                    0.5,
+                    true
+                ],
+                [
+                    228,
+                    0.125,
+                    false
+                ]
+            ],
+            "label": 0,
+            "accuracy": 82.98,
+            "support": 30
+        },
+        {
+            "rule": [
+                [
+                    55,
+                    0.143,
+                    true
+                ],
+                [
+                    47,
+                    0.068,
+                    false
+                ],
+                [
+                    1463,
+                    0.5,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 70.05,
+            "support": 130
+        },
+        {
+            "rule": [
+                [
+                    1312,
+                    0.5,
+                    false
+                ],
+                [
+                    1127,
+                    0.5,
+                    false
+                ],
+                [
+                    1404,
+                    0.5,
+                    false
+                ]
+            ],
+            "label": 0,
+            "accuracy": 75.0,
+            "support": 6
+        },
+        {
+            "rule": [
+                [
+                    659,
+                    0.071,
+                    true
+                ],
+                [
+                    73,
+                    0.202,
+                    false
+                ],
+                [
+                    425,
+                    0.188,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 86.6,
+            "support": 65
+        },
+        {
+            "rule": [
+                [
+                    201,
+                    0.593,
+                    false
+                ],
+                [
+                    612,
+                    0.062,
+                    false
+                ],
+                [
+                    91,
+                    0.026,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 100.0,
+            "support": 6
+        },
+        {
+            "rule": [
+                [
+                    83,
+                    0.086,
+                    true
+                ],
+                [
+                    102,
+                    0.377,
+                    false
+                ],
+                [
+                    181,
+                    0.315,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 87.3,
+            "support": 32
+        },
+        {
+            "rule": [
+                [
+                    20,
+                    0.016,
+                    false
+                ],
+                [
+                    38,
+                    0.155,
+                    true
+                ],
+                [
+                    9,
+                    0.14,
+                    false
+                ]
+            ],
+            "label": 0,
+            "accuracy": 50.0,
+            "support": 31
+        },
+        {
+            "rule": [
+                [
+                    197,
+                    0.09,
+                    false
+                ],
+                [
+                    559,
+                    0.139,
+                    true
+                ],
+                [
+                    503,
+                    0.012,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 86.67,
+            "support": 32
+        },
+        {
+            "rule": [
+                [
+                    176,
+                    0.251,
+                    true
+                ],
+                [
+                    754,
+                    0.038,
+                    true
+                ],
+                [
+                    201,
+                    0.81,
+                    false
+                ]
+            ],
+            "label": 0,
+            "accuracy": 93.62,
+            "support": 27
+        },
+        {
+            "rule": [
+                [
+                    978,
+                    0.5,
+                    false
+                ],
+                [
+                    1026,
+                    0.5,
+                    true
+                ],
+                [
+                    181,
+                    0.217,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 57.42,
+            "support": 163
+        },
+        {
+            "rule": [
+                [
+                    594,
+                    0.15,
+                    true
+                ],
+                [
+                    1222,
+                    0.5,
+                    true
+                ],
+                [
+                    4,
+                    0.165,
+                    false
+                ]
+            ],
+            "label": 0,
+            "accuracy": 65.21,
+            "support": 279
+        },
+        {
+            "rule": [
+                [
+                    958,
+                    0.5,
+                    true
+                ],
+                [
+                    144,
+                    0.163,
+                    true
+                ],
+                [
+                    1215,
+                    0.5,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 64.11,
+            "support": 247
+        },
+        {
+            "rule": [
+                [
+                    99,
+                    0.728,
+                    false
+                ],
+                [
+                    1449,
+                    0.5,
+                    true
+                ],
+                [
+                    117,
+                    0.784,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 100.0,
+            "support": 1
+        },
+        {
+            "rule": [
+                [
+                    1068,
+                    0.5,
+                    true
+                ],
+                [
+                    426,
+                    0.125,
+                    true
+                ],
+                [
+                    73,
+                    0.337,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 55.78,
+            "support": 287
+        },
+        {
+            "rule": [
+                [
+                    658,
+                    0.219,
+                    false
+                ],
+                [
+                    410,
+                    0.125,
+                    true
+                ],
+                [
+                    841,
+                    0.083,
+                    true
+                ]
+            ],
+            "label": 1,
+            "accuracy": 71.58,
+            "support": 185
+        }
+    ],
+    "rules_description": [
+        "if (D741 > 0.054) and (D219 > 0.663) and (D1272 > 0.5) then class: 1 (proba: 100.0%) | based on 2 samples",
+        "if (D86 > 0.166) and (D1723 <= 0.5) and (D103 <= 0.255) then class: 0 (proba: 75.0%) | based on 5 samples",
+        "if (D5 > 0.162) and (D195 > 0.737) and (D15 <= 0.558) then class: 0 (proba: 66.67%) | based on 8 samples",
+        "if (D598 <= 0.125) and (D701 <= 0.033) and (D1341 > 0.5) then class: 1 (proba: 75.0%) | based on 29 samples",
+        "if (D451 <= 0.083) and (D1109 <= 0.5) and (D83 > 0.389) then class: 1 (proba: 77.27%) | based on 27 samples",
+        "if (D99 <= 0.707) and (D1367 <= 0.5) and (D229 > 0.125) then class: 0 (proba: 82.98%) | based on 30 samples",
+        "if (D56 <= 0.143) and (D48 > 0.068) and (D1464 <= 0.5) then class: 0 (proba: 70.05%) | based on 130 samples",
+        "if (D1313 > 0.5) and (D1128 > 0.5) and (D1405 > 0.5) then class: 0 (proba: 75.0%) | based on 6 samples",
+        "if (D660 <= 0.071) and (D74 > 0.202) and (D426 <= 0.188) then class: 0 (proba: 86.6%) | based on 65 samples",
+        "if (D202 > 0.593) and (D613 > 0.062) and (D92 > 0.026) then class: 1 (proba: 100.0%) | based on 6 samples",
+        "if (D84 <= 0.086) and (D103 > 0.377) and (D182 <= 0.315) then class: 0 (proba: 87.3%) | based on 32 samples",
+        "if (D21 > 0.016) and (D39 <= 0.155) and (D10 > 0.14) then class: 0 (proba: 50.0%) | based on 31 samples",
+        "if (D198 > 0.09) and (D560 <= 0.139) and (D504 <= 0.012) then class: 0 (proba: 86.67%) | based on 32 samples",
+        "if (D177 <= 0.251) and (D755 <= 0.038) and (D202 > 0.81) then class: 0 (proba: 93.62%) | based on 27 samples",
+        "if (D979 > 0.5) and (D1027 <= 0.5) and (D182 <= 0.217) then class: 0 (proba: 57.42%) | based on 163 samples",
+        "if (D595 <= 0.15) and (D1223 <= 0.5) and (D5 > 0.165) then class: 0 (proba: 65.21%) | based on 279 samples",
+        "if (D959 <= 0.5) and (D145 <= 0.163) and (D1216 <= 0.5) then class: 0 (proba: 64.11%) | based on 247 samples",
+        "if (D100 > 0.728) and (D1450 <= 0.5) and (D118 > 0.784) then class: 1 (proba: 100.0%) | based on 1 samples",
+        "if (D1069 <= 0.5) and (D427 <= 0.125) and (D74 <= 0.337) then class: 0 (proba: 55.78%) | based on 287 samples",
+        "if (D659 > 0.219) and (D411 <= 0.125) and (D842 <= 0.083) then class: 1 (proba: 71.58%) | based on 185 samples"
+    ],
+    "config": {
+        "n_trees": 20,
+        "max_depth": 3,
+        "max_features": 20,
+        "used_data": 0.2
+    }
+}

classification/Bioresponse/train.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c597e58013825c4cf6f83cd9c0126decd5c99d791561dddcb9498d428092ae6
+size 29881496

classification/PhishingWebsites/label.json

@@ -0,0 +1,4 @@
+{
+	"0": "-1",
+	"1": "1"
+}

classification/PhishingWebsites/rules.json

@@ -0,0 +1,357 @@
+{
+    "rules": [
+        {
+            "rule": [
+                [
+                    7,
+                    0.5,
+                    false
+                ],
+                [
+                    13,
+                    0.5,
+                    true
+                ],
+                [
+                    24,
+                    0.5,
+                    false
+                ]
+            ],
+            "label": 0,
+            "accuracy": 98.61,
+            "support": 48
+        },
+        {
+            "rule": [
+                [
+                    7,
+                    0.5,
+                    true
+                ],
+                [
+                    19,
+                    0.5,
+                    false
+                ],
+                [
+                    12,
+                    0.5,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 96.67,
+            "support": 19
+        },
+        {
+            "rule": [
+                [
+                    18,
+                    0.5,
+                    false
+                ],
+                [
+                    7,
+                    0.5,
+                    false
+                ],
+                [
+                    25,
+                    1.5,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 89.19,
+            "support": 25
+        },
+        {
+            "rule": [
+                [
+                    15,
+                    0.5,
+                    true
+                ],
+                [
+                    5,
+                    0.5,
+                    true
+                ],
+                [
+                    3,
+                    0.5,
+                    false
+                ]
+            ],
+            "label": 0,
+            "accuracy": 74.14,
+            "support": 74
+        },
+        {
+            "rule": [
+                [
+                    25,
+                    1.5,
+                    true
+                ],
+                [
+                    23,
+                    0.5,
+                    false
+                ],
+                [
+                    12,
+                    0.5,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 50.0,
+            "support": 95
+        },
+        {
+            "rule": [
+                [
+                    8,
+                    0.5,
+                    false
+                ],
+                [
+                    25,
+                    1.5,
+                    true
+                ],
+                [
+                    18,
+                    0.5,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 74.86,
+            "support": 108
+        },
+        {
+            "rule": [
+                [
+                    13,
+                    0.5,
+                    false
+                ],
+                [
+                    17,
+                    0.5,
+                    false
+                ],
+                [
+                    6,
+                    1.5,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 88.97,
+            "support": 188
+        },
+        {
+            "rule": [
+                [
+                    14,
+                    0.5,
+                    false
+                ],
+                [
+                    17,
+                    0.5,
+                    false
+                ],
+                [
+                    7,
+                    0.5,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 91.69,
+            "support": 199
+        },
+        {
+            "rule": [
+                [
+                    6,
+                    1.5,
+                    true
+                ],
+                [
+                    14,
+                    0.5,
+                    false
+                ],
+                [
+                    25,
+                    1.5,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 57.03,
+            "support": 163
+        },
+        {
+            "rule": [
+                [
+                    5,
+                    0.5,
+                    true
+                ],
+                [
+                    7,
+                    0.5,
+                    false
+                ],
+                [
+                    6,
+                    1.5,
+                    true
+                ]
+            ],
+            "label": 1,
+            "accuracy": 56.23,
+            "support": 226
+        },
+        {
+            "rule": [
+                [
+                    13,
+                    0.5,
+                    false
+                ],
+                [
+                    17,
+                    0.5,
+                    false
+                ],
+                [
+                    23,
+                    0.5,
+                    true
+                ]
+            ],
+            "label": 1,
+            "accuracy": 65.52,
+            "support": 182
+        },
+        {
+            "rule": [
+                [
+                    14,
+                    0.5,
+                    false
+                ],
+                [
+                    8,
+                    0.5,
+                    true
+                ],
+                [
+                    13,
+                    0.5,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 72.7,
+            "support": 239
+        },
+        {
+            "rule": [
+                [
+                    13,
+                    0.5,
+                    true
+                ],
+                [
+                    28,
+                    0.5,
+                    true
+                ],
+                [
+                    7,
+                    0.5,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 100.0,
+            "support": 65
+        },
+        {
+            "rule": [
+                [
+                    5,
+                    0.5,
+                    true
+                ],
+                [
+                    14,
+                    0.5,
+                    true
+                ],
+                [
+                    4,
+                    0.5,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 77.19,
+            "support": 34
+        },
+        {
+            "rule": [
+                [
+                    5,
+                    0.5,
+                    true
+                ],
+                [
+                    28,
+                    1.5,
+                    true
+                ],
+                [
+                    25,
+                    1.5,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 75.35,
+            "support": 327
+        }
+    ],
+    "rules_description": [
+        "if (SSLfinal_State > 0.5) and (URL_of_Anchor <= 0.5) and (DNSRecord > 0.5) then class: -1 (proba: 98.61%) | based on 48 samples",
+        "if (SSLfinal_State <= 0.5) and (on_mouseover > 0.5) and (Request_URL <= 0.5) then class: -1 (proba: 96.67%) | based on 19 samples",
+        "if (Redirect > 0.5) and (SSLfinal_State > 0.5) and (web_traffic > 1.5) then class: 1 (proba: 89.19%) | based on 25 samples",
+        "if (SFH <= 0.5) and (Prefix_Suffix <= 0.5) and (having_At_Symbol > 0.5) then class: -1 (proba: 74.14%) | based on 74 samples",
+        "if (web_traffic <= 1.5) and (age_of_domain > 0.5) and (Request_URL <= 0.5) then class: -1 (proba: 50.0%) | based on 95 samples",
+        "if (Domain_registeration_length > 0.5) and (web_traffic <= 1.5) and (Redirect <= 0.5) then class: -1 (proba: 74.86%) | based on 108 samples",
+        "if (URL_of_Anchor > 0.5) and (Abnormal_URL > 0.5) and (having_Sub_Domain > 1.5) then class: 1 (proba: 88.97%) | based on 188 samples",
+        "if (Links_in_tags > 0.5) and (Abnormal_URL > 0.5) and (SSLfinal_State <= 0.5) then class: -1 (proba: 91.69%) | based on 199 samples",
+        "if (having_Sub_Domain <= 1.5) and (Links_in_tags > 0.5) and (web_traffic > 1.5) then class: 1 (proba: 57.03%) | based on 163 samples",
+        "if (Prefix_Suffix <= 0.5) and (SSLfinal_State > 0.5) and (having_Sub_Domain <= 1.5) then class: 1 (proba: 56.23%) | based on 226 samples",
+        "if (URL_of_Anchor > 0.5) and (Abnormal_URL > 0.5) and (age_of_domain <= 0.5) then class: 1 (proba: 65.52%) | based on 182 samples",
+        "if (Links_in_tags > 0.5) and (Domain_registeration_length <= 0.5) and (URL_of_Anchor > 0.5) then class: 1 (proba: 72.7%) | based on 239 samples",
+        "if (URL_of_Anchor <= 0.5) and (Links_pointing_to_page <= 0.5) and (SSLfinal_State <= 0.5) then class: -1 (proba: 100.0%) | based on 65 samples",
+        "if (Prefix_Suffix <= 0.5) and (Links_in_tags <= 0.5) and (double_slash_redirecting <= 0.5) then class: -1 (proba: 77.19%) | based on 34 samples",
+        "if (Prefix_Suffix <= 0.5) and (Links_pointing_to_page <= 1.5) and (web_traffic <= 1.5) then class: -1 (proba: 75.35%) | based on 327 samples"
+    ],
+    "config": {
+        "n_trees": 15,
+        "max_depth": 3,
+        "max_features": 4,
+        "used_data": 0.1
+    }
+}

classification/agnews/label.json

@@ -0,0 +1,6 @@
+{
+    "0": "World",
+    "1": "Sports",
+    "2": "Business",
+    "3": "Sci/Tech"
+}

classification/agnews/readme.txt

@@ -0,0 +1,87 @@
+Agnews Topic classification dataset
+
+https://github.com/weakrules/Denoise-multi-weak-sources/blob/master/rules-noisy-labels/Agnews/angews_rule.py
+
+
+# Labels 
+"0": "World",
+"1": "Sports",
+"2": "Business",
+"3": "Sci/Tech"
+
+
+
+
+
+
+
+# Labeling functions (all 9 lf are keyword lf)
+
+## LF1  0: world
+
+r1 = ["atomic", "captives", "baghdad", "israeli", "iraqis", "iranian", "afghanistan", "wounding", "terrorism", "soldiers", \
+"palestinians", "palestinian", "policemen", "iraqi", "terrorist", 'north korea', 'korea', \
+'israel', 'u.n.', 'egypt', 'iran', 'iraq', 'nato', 'armed', 'peace']
+
+
+## LF2  0: world
+
+r2= [' war ', 'prime minister', 'president', 'commander', 'minister',  'annan', "military", "militant", "kill", 'operator']
+
+
+
+
+## LF3  1: sports
+
+r3 = ["goals", "bledsoe", "coaches",  "touchdowns", "kansas", "rankings", "no.", \
+    "champ", "cricketers", "hockey", "champions", "quarterback", 'club', 'team',  'baseball', 'basketball', 'soccer', 'football', 'boxing',  'swimming', \
+    'world cup', 'nba',"olympics","final", "finals", 'fifa',  'racist', 'racism'] 
+
+
+
+## LF4   1: sports
+
+r4 = ['athlete',  'striker', 'defender', 'goalkeeper',  'midfielder', 'shooting guard', 'power forward', 'point guard', 'pitcher', 'catcher', 'first base', 'second base', 'third base','shortstop','fielder']
+
+
+
+
+## LF5   1: sports
+
+r5=['lakers','chelsea', 'piston','cavaliers', 'rockets', 'clippers','ronaldo', \
+    'celtics', 'hawks','76ers', 'raptors', 'pacers', 'suns', 'warriors','blazers','knicks','timberwolves', 'hornets', 'wizards', 'nuggets', 'mavericks', 'grizzlies', 'spurs', \
+    'cowboys', 'redskins', 'falcons', 'panthers', 'eagles', 'saints', 'buccaneers', '49ers', 'cardinals', 'texans', 'seahawks', 'vikings', 'patriots', 'colts', 'jaguars', 'raiders', 'chargers', 'bengals', 'steelers', 'browns', \
+    'braves','marlins','mets','phillies','cubs','brewers','cardinals', 'diamondbacks','rockies', 'dodgers', 'padres', 'orioles', 'sox', 'yankees', 'jays', 'sox', 'indians', 'tigers', 'royals', 'twins','astros', 'angels', 'athletics', 'mariners', 'rangers', \
+    'arsenal', 'burnley', 'newcastle', 'leicester', 'manchester united', 'everton', 'southampton', 'hotspur','tottenham', 'fulham', 'watford', 'sheffield','crystal palace', 'derby', 'charlton', 'aston villa', 'blackburn', 'west ham', 'birmingham city', 'middlesbrough', \
+    'real madrid', 'barcelona', 'villarreal', 'valencia', 'betis', 'espanyol','levante', 'sevilla', 'juventus', 'inter milan', 'ac milan', 'as roma', 'benfica', 'porto', 'getafe', 'bayern', 'schalke', 'bremen', 'lyon', 'paris saint', 'monaco', 'dynamo']
+
+
+
+ 
+## LF6  3: tech
+
+r6 = ["technology", "engineering", "science", "research", "cpu", "windows", "unix", "system", 'computing',  'compute']#, "wireless","chip", "pc", ]
+
+
+
+
+## LF7  3: tech
+
+r7= ["google", "apple", "microsoft", "nasa", "yahoo", "intel", "dell", \
+    'huawei',"ibm", "siemens", "nokia", "samsung", 'panasonic', \
+    't-mobile', 'nvidia', 'adobe', 'salesforce', 'linkedin', 'silicon', 'wiki'
+]
+
+
+
+
+## LF8  - 2:business
+
+r8= ["stock", "account", "financ", "goods", "retail", 'economy', 'chairman', 'bank', 'deposit', 'economic', 'dow jones', 'index', '$',  'percent', 'interest rate', 'growth', 'profit', 'tax', 'loan',  'credit', 'invest']
+
+
+
+
+## LF9  - 2:business
+
+r9= ["delta", "cola", "toyota", "costco", "gucci", 'citibank', 'airlines']

classification/agnews/train.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6aa806387c07ad0ee53d3ecebcc47dc0c22c2961cd34e248656d32441ba079a3
+size 28043077

classification/bank-marketing/label.json

@@ -0,0 +1,4 @@
+{
+	"0": "1",
+	"1": "2"
+}

classification/bank-marketing/rules.json

@@ -0,0 +1,472 @@
+{
+    "rules": [
+        {
+            "rule": [
+                [
+                    15,
+                    2.5,
+                    false
+                ],
+                [
+                    5,
+                    21726.0,
+                    false
+                ],
+                [
+                    6,
+                    0.5,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 100.0,
+            "support": 1
+        },
+        {
+            "rule": [
+                [
+                    15,
+                    2.5,
+                    false
+                ],
+                [
+                    13,
+                    313.0,
+                    false
+                ],
+                [
+                    11,
+                    50.5,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 100.0,
+            "support": 2
+        },
+        {
+            "rule": [
+                [
+                    11,
+                    215.5,
+                    true
+                ],
+                [
+                    14,
+                    0.5,
+                    false
+                ],
+                [
+                    15,
+                    2.5,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 84.98,
+            "support": 171
+        },
+        {
+            "rule": [
+                [
+                    8,
+                    0.5,
+                    true
+                ],
+                [
+                    10,
+                    2.5,
+                    false
+                ],
+                [
+                    10,
+                    4.5,
+                    false
+                ]
+            ],
+            "label": 0,
+            "accuracy": 58.14,
+            "support": 26
+        },
+        {
+            "rule": [
+                [
+                    14,
+                    0.5,
+                    false
+                ],
+                [
+                    11,
+                    158.5,
+                    false
+                ],
+                [
+                    15,
+                    2.5,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 95.21,
+            "support": 504
+        },
+        {
+            "rule": [
+                [
+                    0,
+                    60.5,
+                    true
+                ],
+                [
+                    15,
+                    2.5,
+                    false
+                ],
+                [
+                    11,
+                    119.5,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 95.07,
+            "support": 463
+        },
+        {
+            "rule": [
+                [
+                    5,
+                    103.5,
+                    true
+                ],
+                [
+                    14,
+                    0.5,
+                    false
+                ],
+                [
+                    11,
+                    199.5,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 71.9,
+            "support": 83
+        },
+        {
+            "rule": [
+                [
+                    13,
+                    9.0,
+                    false
+                ],
+                [
+                    11,
+                    159.5,
+                    true
+                ],
+                [
+                    6,
+                    0.5,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 83.72,
+            "support": 166
+        },
+        {
+            "rule": [
+                [
+                    11,
+                    208.5,
+                    false
+                ],
+                [
+                    14,
+                    0.5,
+                    false
+                ],
+                [
+                    15,
+                    2.5,
+                    true
+                ]
+            ],
+            "label": 1,
+            "accuracy": 74.56,
+            "support": 539
+        },
+        {
+            "rule": [
+                [
+                    8,
+                    0.5,
+                    true
+                ],
+                [
+                    3,
+                    1.5,
+                    false
+                ],
+                [
+                    10,
+                    3.0,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 77.78,
+            "support": 7
+        },
+        {
+            "rule": [
+                [
+                    0,
+                    60.5,
+                    false
+                ],
+                [
+                    8,
+                    0.5,
+                    false
+                ],
+                [
+                    8,
+                    1.5,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 80.99,
+            "support": 96
+        },
+        {
+            "rule": [
+                [
+                    15,
+                    2.5,
+                    true
+                ],
+                [
+                    11,
+                    362.5,
+                    false
+                ],
+                [
+                    0,
+                    60.5,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 91.23,
+            "support": 99
+        },
+        {
+            "rule": [
+                [
+                    5,
+                    930.5,
+                    false
+                ],
+                [
+                    15,
+                    2.5,
+                    true
+                ],
+                [
+                    8,
+                    0.5,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 59.69,
+            "support": 1552
+        },
+        {
+            "rule": [
+                [
+                    7,
+                    0.5,
+                    false
+                ],
+                [
+                    11,
+                    526.5,
+                    false
+                ],
+                [
+                    2,
+                    0.5,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 88.89,
+            "support": 86
+        },
+        {
+            "rule": [
+                [
+                    14,
+                    0.5,
+                    true
+                ],
+                [
+                    11,
+                    360.5,
+                    true
+                ],
+                [
+                    0,
+                    60.5,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 76.88,
+            "support": 111
+        },
+        {
+            "rule": [
+                [
+                    13,
+                    4.0,
+                    true
+                ],
+                [
+                    5,
+                    236.5,
+                    false
+                ],
+                [
+                    11,
+                    393.5,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 80.3,
+            "support": 1018
+        },
+        {
+            "rule": [
+                [
+                    14,
+                    0.5,
+                    true
+                ],
+                [
+                    5,
+                    77.5,
+                    false
+                ],
+                [
+                    11,
+                    322.5,
+                    false
+                ]
+            ],
+            "label": 1,
+            "accuracy": 76.77,
+            "support": 1400
+        },
+        {
+            "rule": [
+                [
+                    15,
+                    2.5,
+                    true
+                ],
+                [
+                    8,
+                    0.5,
+                    true
+                ],
+                [
+                    5,
+                    414.5,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 80.94,
+            "support": 629
+        },
+        {
+            "rule": [
+                [
+                    15,
+                    2.5,
+                    true
+                ],
+                [
+                    11,
+                    365.5,
+                    true
+                ],
+                [
+                    10,
+                    7.5,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 81.56,
+            "support": 2616
+        },
+        {
+            "rule": [
+                [
+                    8,
+                    0.5,
+                    true
+                ],
+                [
+                    11,
+                    472.5,
+                    true
+                ],
+                [
+                    15,
+                    0.5,
+                    true
+                ]
+            ],
+            "label": 0,
+            "accuracy": 95.6,
+            "support": 853
+        }
+    ],
+    "rules_description": [
+        "if (V16 > 2.5) and (V6 > 21726.0) and (V7 <= 0.5) then class: 1 (proba: 100.0%) | based on 1 samples",
+        "if (V16 > 2.5) and (V14 > 313.0) and (V12 <= 50.5) then class: 1 (proba: 100.0%) | based on 2 samples",
+        "if (V12 <= 215.5) and (V15 > 0.5) and (V16 > 2.5) then class: 2 (proba: 84.98%) | based on 171 samples",
+        "if (V9 <= 0.5) and (V11 > 2.5) and (V11 > 4.5) then class: 1 (proba: 58.14%) | based on 26 samples",
+        "if (V15 > 0.5) and (V12 > 158.5) and (V16 > 2.5) then class: 2 (proba: 95.21%) | based on 504 samples",
+        "if (V1 <= 60.5) and (V16 > 2.5) and (V12 > 119.5) then class: 2 (proba: 95.07%) | based on 463 samples",
+        "if (V6 <= 103.5) and (V15 > 0.5) and (V12 <= 199.5) then class: 1 (proba: 71.9%) | based on 83 samples",
+        "if (V14 > 9.0) and (V12 <= 159.5) and (V7 <= 0.5) then class: 1 (proba: 83.72%) | based on 166 samples",
+        "if (V12 > 208.5) and (V15 > 0.5) and (V16 <= 2.5) then class: 2 (proba: 74.56%) | based on 539 samples",
+        "if (V9 <= 0.5) and (V4 > 1.5) and (V11 > 3.0) then class: 2 (proba: 77.78%) | based on 7 samples",
+        "if (V1 > 60.5) and (V9 > 0.5) and (V9 > 1.5) then class: 2 (proba: 80.99%) | based on 96 samples",
+        "if (V16 <= 2.5) and (V12 > 362.5) and (V1 > 60.5) then class: 2 (proba: 91.23%) | based on 99 samples",
+        "if (V6 > 930.5) and (V16 <= 2.5) and (V9 > 0.5) then class: 2 (proba: 59.69%) | based on 1,552 samples",
+        "if (V8 > 0.5) and (V12 > 526.5) and (V3 > 0.5) then class: 2 (proba: 88.89%) | based on 86 samples",
+        "if (V15 <= 0.5) and (V12 <= 360.5) and (V1 > 60.5) then class: 2 (proba: 76.88%) | based on 111 samples",
+        "if (V14 <= 4.0) and (V6 > 236.5) and (V12 > 393.5) then class: 2 (proba: 80.3%) | based on 1,018 samples",
+        "if (V15 <= 0.5) and (V6 > 77.5) and (V12 > 322.5) then class: 2 (proba: 76.77%) | based on 1,400 samples",
+        "if (V16 <= 2.5) and (V9 <= 0.5) and (V6 <= 414.5) then class: 1 (proba: 80.94%) | based on 629 samples",
+        "if (V16 <= 2.5) and (V12 <= 365.5) and (V11 <= 7.5) then class: 1 (proba: 81.56%) | based on 2,616 samples",
+        "if (V9 <= 0.5) and (V12 <= 472.5) and (V16 <= 0.5) then class: 1 (proba: 95.6%) | based on 853 samples"
+    ],
+    "config": {
+        "n_trees": 20,
+        "max_depth": 3,
+        "max_features": 4,
+        "used_data": 0.2
+    }
+}

classification/basketball/label.json

@@ -0,0 +1 @@
+{"0": 0, "1": 1}

classification/basketball/readme.txt

@@ -0,0 +1,18 @@
+Basketball - A Video Dataset for Activity Recognition in the Basketball Game
+
+# Source:
+
+D. Y. Fu, M. F. Chen, F. Sala, S. M. Hooper, K. Fatahalian, and C. Ré. Fast and three-rious: Speeding up weak supervision with triplet methods. In ICML, pages 3280–3291, 2020.
+
+
+# Labels:
+
+0: negative (the game is not basketball)
+
+1: positive (the game is basketball)
+
+
+
+4 Labeling functions
+
+LFs: these sources rely on an off-the-shelf object detector to detect balls or people, and use heuristics based on the average pixel of the detected ball or distance between the ball and person to determine whether the sport being played is basketball or not.

classification/basketball/test.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ef43d2a39e7d08de16b0c95cbeeef9f10e59600c3e7e1d2a2f6c36be974bc685
+size 52411265

classification/basketball/train.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af2bf8f5d7fc78a50edbf8ad16fc18aa86ba5f8d57467cffe5c43b90f4920683
+size 771265380

classification/basketball/valid.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:84cd4595908e00030bd6132269c6f10e5d1ee9f118c48b4e7150f91bfb18bc36
+size 45661535

classification/cdr/label.json

@@ -0,0 +1 @@
+{"0": "Negative", "1": "Positive"}

classification/cdr/readme.txt

@@ -0,0 +1,286 @@
+CDR - Extracting Chemical-Disease Relations from Academic Literature
+
+# Source:
+ https://github.com/snorkel-team/snorkel-extraction/tree/master/tutorials/cdr
+
+# Labels:
+
+0: Negative, the drug does NOT induce the disease
+1: Positive, the drug induces the disease
+
+
+
+33 Label functions (Use ctrl+F to search for implementation)
+LFs = [
+    LF_c_cause_d,
+    LF_c_d,
+    LF_c_induced_d,
+    LF_c_treat_d,
+    LF_c_treat_d_wide,
+    LF_closer_chem,
+    LF_closer_dis,
+    LF_ctd_marker_c_d,
+    LF_ctd_marker_induce,
+    LF_ctd_therapy_treat,
+    LF_ctd_unspecified_treat,
+    LF_ctd_unspecified_induce,
+    LF_d_following_c,
+    LF_d_induced_by_c,
+    LF_d_induced_by_c_tight,
+    LF_d_treat_c,
+    LF_develop_d_following_c,
+    LF_far_c_d,
+    LF_far_d_c,
+    LF_improve_before_disease,
+    LF_in_ctd_therapy,
+    LF_in_ctd_marker,
+    LF_in_patient_with,
+    LF_induce,
+    LF_induce_name,
+    LF_induced_other,
+    LF_level,
+    LF_measure,
+    LF_neg_d,
+    LF_risk_d,
+    LF_treat_d,
+    LF_uncertain,
+    LF_weak_assertions,
+]
+
+
+##### Distant supervision approaches
+# We'll use the [Comparative Toxicogenomics Database](http://ctdbase.org/) (CTD) for distant supervision.
+# The CTD lists chemical-condition entity pairs under three categories: therapy, marker, and unspecified.
+# Therapy means the chemical treats the condition, marker means the chemical is typically present with the condition,
+# and unspecified is...unspecified. We can write LFs based on these categories.
+
+### LF_in_ctd_unspecified
+def LF_in_ctd_unspecified(c):
+    return -1 * cand_in_ctd_unspecified(c)
+
+### LF_in_ctd_therapy
+def LF_in_ctd_therapy(c):
+    return -1 * cand_in_ctd_therapy(c)
+
+### LF_in_ctd_marker 
+def LF_in_ctd_marker(c):
+    return cand_in_ctd_marker(c)
+
+
+
+
+
+##### Text pattern approaches
+# Now we'll use some LF helpers to create LFs based on indicative text patterns.
+# We came up with these rules by using the viewer to examine training candidates and noting frequent patterns.
+
+import re
+from snorkel.lf_helpers import (
+    get_tagged_text,
+    rule_regex_search_tagged_text,
+    rule_regex_search_btw_AB,
+    rule_regex_search_btw_BA,
+    rule_regex_search_before_A,
+    rule_regex_search_before_B,
+)
+
+# List to parenthetical
+def ltp(x):
+    return '(' + '|'.join(x) + ')'
+
+### LF_induce
+def LF_induce(c):
+    return 1 if re.search(r'{{A}}.{0,20}induc.{0,20}{{B}}', get_tagged_text(c), flags=re.I) else 0
+
+### LF_d_induced_by_c
+causal_past = ['induced', 'caused', 'due']
+def LF_d_induced_by_c(c):
+    return rule_regex_search_btw_BA(c, '.{0,50}' + ltp(causal_past) + '.{0,9}(by|to).{0,50}', 1)
+
+### LF_d_induced_by_c_tight
+def LF_d_induced_by_c_tight(c):
+    return rule_regex_search_btw_BA(c, '.{0,50}' + ltp(causal_past) + ' (by|to) ', 1)
+
+### LF_induce_name
+def LF_induce_name(c):
+    return 1 if 'induc' in c.chemical.get_span().lower() else 0     
+
+### LF_c_cause_d
+causal = ['cause[sd]?', 'induce[sd]?', 'associated with']
+def LF_c_cause_d(c):
+    return 1 if (
+        re.search(r'{{A}}.{0,50} ' + ltp(causal) + '.{0,50}{{B}}', get_tagged_text(c), re.I)
+        and not re.search('{{A}}.{0,50}(not|no).{0,20}' + ltp(causal) + '.{0,50}{{B}}', get_tagged_text(c), re.I)
+    ) else 0
+
+### LF_d_treat_c
+treat = ['treat', 'effective', 'prevent', 'resistant', 'slow', 'promise', 'therap']
+def LF_d_treat_c(c):
+    return rule_regex_search_btw_BA(c, '.{0,50}' + ltp(treat) + '.{0,50}', -1)
+
+### LF_c_treat_d
+def LF_c_treat_d(c):
+    return rule_regex_search_btw_AB(c, '.{0,50}' + ltp(treat) + '.{0,50}', -1)
+
+### LF_treat_d
+def LF_treat_d(c):
+    return rule_regex_search_before_B(c, ltp(treat) + '.{0,50}', -1)
+
+### LF_c_treat_d_wide
+def LF_c_treat_d_wide(c):
+    return rule_regex_search_btw_AB(c, '.{0,200}' + ltp(treat) + '.{0,200}', -1)
+
+### LF_c_d
+def LF_c_d(c):
+    return 1 if ('{{A}} {{B}}' in get_tagged_text(c)) else 0
+
+### LF_c_induced_d
+def LF_c_induced_d(c):
+    return 1 if (
+        ('{{A}} {{B}}' in get_tagged_text(c)) and 
+        (('-induc' in c[0].get_span().lower()) or ('-assoc' in c[0].get_span().lower()))
+        ) else 0
+
+### LF_improve_before_disease
+def LF_improve_before_disease(c):
+    return rule_regex_search_before_B(c, 'improv.*', -1)
+
+### LF_in_patient_with
+pat_terms = ['in a patient with ', 'in patients with']
+def LF_in_patient_with(c):
+    return -1 if re.search(ltp(pat_terms) + '{{B}}', get_tagged_text(c), flags=re.I) else 0
+
+### LF_uncertain
+uncertain = ['combin', 'possible', 'unlikely']
+def LF_uncertain(c):
+    return rule_regex_search_before_A(c, ltp(uncertain) + '.*', -1)
+
+### LF_induced_other
+def LF_induced_other(c):
+    return rule_regex_search_tagged_text(c, '{{A}}.{20,1000}-induced {{B}}', -1)
+
+### LF_far_c_d
+def LF_far_c_d(c):
+    return rule_regex_search_btw_AB(c, '.{100,5000}', -1)
+
+### LF_far_d_c
+def LF_far_d_c(c):
+    return rule_regex_search_btw_BA(c, '.{100,5000}', -1)
+
+### LF_risk_d
+def LF_risk_d(c):
+    return rule_regex_search_before_B(c, 'risk of ', 1)
+
+### LF_develop_d_following_c
+def LF_develop_d_following_c(c):
+    return 1 if re.search(r'develop.{0,25}{{B}}.{0,25}following.{0,25}{{A}}', get_tagged_text(c), flags=re.I) else 0
+
+### LF_d_following_c
+procedure, following = ['inject', 'administrat'], ['following']
+def LF_d_following_c(c):
+    return 1 if re.search('{{B}}.{0,50}' + ltp(following) + '.{0,20}{{A}}.{0,50}' + ltp(procedure), get_tagged_text(c), flags=re.I) else 0
+
+### LF_measure
+def LF_measure(c):
+    return -1 if re.search('measur.{0,75}{{A}}', get_tagged_text(c), flags=re.I) else 0
+
+### LF_level
+def LF_level(c):
+    return -1 if re.search('{{A}}.{0,25} level', get_tagged_text(c), flags=re.I) else 0
+
+### LF_neg_d
+def LF_neg_d(c):
+    return -1 if re.search('(none|not|no) .{0,25}{{B}}', get_tagged_text(c), flags=re.I) else 0
+
+### LF_weak_assertions
+WEAK_PHRASES = ['none', 'although', 'was carried out', 'was conducted',
+                'seems', 'suggests', 'risk', 'implicated',
+               'the aim', 'to (investigate|assess|study)']
+
+WEAK_RGX = r'|'.join(WEAK_PHRASES)
+def LF_weak_assertions(c):
+    return -1 if re.search(WEAK_RGX, get_tagged_text(c), flags=re.I) else 0
+
+
+
+
+
+
+##### Composite LFs
+
+# The following LFs take some of the strongest distant supervision and text pattern LFs,
+# and combine them to form more specific LFs. These LFs introduce some obvious 
+# dependencies within the LF set, which we will model later.
+
+### LF_ctd_marker_c_d
+def LF_ctd_marker_c_d(c):
+    return LF_c_d(c) * cand_in_ctd_marker(c)
+
+### LF_ctd_marker_induce
+def LF_ctd_marker_induce(c):
+    return (LF_c_induced_d(c) or LF_d_induced_by_c_tight(c)) * cand_in_ctd_marker(c)
+
+### LF_ctd_therapy_treat
+def LF_ctd_therapy_treat(c):
+    return LF_c_treat_d_wide(c) * cand_in_ctd_therapy(c)
+
+### LF_ctd_unspecified_treat
+def LF_ctd_unspecified_treat(c):
+    return LF_c_treat_d_wide(c) * cand_in_ctd_unspecified(c)
+
+### LF_ctd_unspecified_induce
+def LF_ctd_unspecified_induce(c):
+    return (LF_c_induced_d(c) or LF_d_induced_by_c_tight(c)) * cand_in_ctd_unspecified(c)
+
+
+
+
+
+
+##### Rules based on context hierarchy
+# These last two rules will make use of the context hierarchy.
+# The first checks if there is a chemical mention much closer to the candidate's disease mention
+# than the candidate's chemical mention. The second does the analog for diseases.
+
+### LF_closer_chem
+def LF_closer_chem(c):
+    # Get distance between chemical and disease
+    chem_start, chem_end = c.chemical.get_word_start(), c.chemical.get_word_end()
+    dis_start, dis_end = c.disease.get_word_start(), c.disease.get_word_end()
+    if dis_start < chem_start:
+        dist = chem_start - dis_end
+    else:
+        dist = dis_start - chem_end
+    # Try to find chemical closer than @dist/2 in either direction
+    sent = c.get_parent()
+    closest_other_chem = float('inf')
+    for i in range(dis_end, min(len(sent.words), dis_end + dist // 2)):
+        et, cid = sent.entity_types[i], sent.entity_cids[i]
+        if et == 'Chemical' and cid != sent.entity_cids[chem_start]:
+            return -1
+    for i in range(max(0, dis_start - dist // 2), dis_start):
+        et, cid = sent.entity_types[i], sent.entity_cids[i]
+        if et == 'Chemical' and cid != sent.entity_cids[chem_start]:
+            return -1
+    return 0
+
+### LF_closer_dis
+def LF_closer_dis(c):
+    # Get distance between chemical and disease
+    chem_start, chem_end = c.chemical.get_word_start(), c.chemical.get_word_end()
+    dis_start, dis_end = c.disease.get_word_start(), c.disease.get_word_end()
+    if dis_start < chem_start:
+        dist = chem_start - dis_end
+    else:
+        dist = dis_start - chem_end
+    # Try to find chemical disease than @dist/8 in either direction
+    sent = c.get_parent()
+    for i in range(chem_end, min(len(sent.words), chem_end + dist // 8)):
+        et, cid = sent.entity_types[i], sent.entity_cids[i]
+        if et == 'Disease' and cid != sent.entity_cids[dis_start]:
+            return -1
+    for i in range(max(0, chem_start - dist // 8), chem_start):
+        et, cid = sent.entity_types[i], sent.entity_cids[i]
+        if et == 'Disease' and cid != sent.entity_cids[dis_start]:
+            return -1
+    return 0

classification/census/label.json

@@ -0,0 +1 @@
+{"0": "negative", "1": "positive"}

classification/census/labeled_ids.json

@@ -0,0 +1,4 @@
+{
+  "labeled_ids": ["10000", "10001", "10002", "10003", "10004", "10005", "10006", "10007", "10008", "10009", "10010", "10011", "10012", "10013", "10014", "10015", "10016", "10017", "10018", "10019", "10020", "10021", "10022", "10023", "10024", "10025", "10026", "10027", "10028", "10029", "10030", "10031", "10032", "10033", "10034", "10035", "10036", "10037", "10038", "10039", "10040", "10041", "10042", "10043", "10044", "10045", "10046", "10047", "10048", "10049", "10050", "10051", "10052", "10053", "10054", "10055", "10056", "10057", "10058", "10059", "10060", "10061", "10062", "10063", "10064", "10065", "10066", "10067", "10068", "10069", "10070", "10071", "10072", "10073", "10074", "10075", "10076", "10077", "10078", "10079", "10080", "10081", "10082"],
+  "lf_exemplar_ids": ["10000", "10001", "10002", "10003", "10004", "10005", "10006", "10007", "10008", "10009", "10010", "10011", "10012", "10013", "10014", "10015", "10016", "10017", "10018", "10019", "10020", "10021", "10022", "10023", "10024", "10025", "10026", "10027", "10028", "10029", "10030", "10031", "10032", "10033", "10034", "10035", "10036", "10037", "10038", "10039", "10040", "10041", "10042", "10043", "10044", "10045", "10046", "10047", "10048", "10049", "10050", "10051", "10052", "10053", "10054", "10055", "10056", "10057", "10058", "10059", "10060", "10061", "10062", "10063", "10064", "10065", "10066", "10067", "10068", "10069", "10070", "10071", "10072", "10073", "10074", "10075", "10076", "10077", "10078", "10079", "10080", "10081", "10082"]
+}

classification/census/readme.txt

@@ -0,0 +1,20 @@
+Census income classification
+
+http://archive.ics.uci.edu/ml/datasets/Census+Income
+
+
+Label:
+Negative : person earns lees than or equal to 50K
+Positive : person earns more than 50k
+
+Rules:
+
+For this case we created the rules synthetically as follows:
+We hold out disjoint 16k random points from the training dataset as a proxy for human knowledge and extract a PART decision list from it as our set of rules. We retain only
+those rules which fire on L.
+
+https://mathematicaforprediction.wordpress.com/2014/03/30/classification-and-association-rules-for-census-income-data/
+
+
+
+

classification/census/test.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad12ab08dd411302b2bb62e260882fba1a3fba9950755f4de39176ed25b6fa17
+size 15846146

classification/chemprot/label.json

@@ -0,0 +1,12 @@
+{
+    "0": "Part of",
+    "1": "Regulator",
+    "2": "Upregulator",
+    "3": "Downregulator",
+    "4": "Agonist",
+    "5": "Antagonist",
+    "6": "Modulator",
+    "7": "Cofactor",
+    "8": "Substrate/Product",
+    "9": "NOT"
+}

classification/chemprot/readme.txt

@@ -0,0 +1,213 @@
+Chemprot Relation Classification Dataset
+https://github.com/yueyu1030/COSINE/tree/main/data/chemprot
+
+
+
+# Labels
+
+    "0": "Part of",
+    "1": "Regulator",
+    "2": "Upregulator",
+    "3": "Downregulator",
+    "4": "Agonist",
+    "5": "Antagonist",
+    "6": "Modulator",
+    "7": "Cofactor",
+    "8": "Substrate/Product",
+    "9": "NOT"
+
+
+
+
+# Labeling Functions
+
+
+## Part of
+@labeling_function()
+def lf_amino_acid(x):
+    return 1 if 'amino acid' in x.sentence.lower() else ABSTAIN
+
+@labeling_function()
+def lf_replace(x):
+    return 1 if 'replace' in x.sentence.lower() else ABSTAIN
+
+@labeling_function()
+def lf_mutant(x):
+    return 1 if 'mutant' in x.sentence.lower() or 'mutat' in x.sentence.lower() else ABSTAIN
+
+
+
+
+
+
+
+
+## Regulator
+@labeling_function()
+def lf_bind(x):
+    return 2 if 'bind' in x.sentence.lower() else ABSTAIN
+
+@labeling_function()
+def lf_interact(x):
+    return 2 if 'interact' in x.sentence.lower() else ABSTAIN
+
+@labeling_function()
+def lf_affinity(x):
+    return 2 if 'affinit' in x.sentence.lower() else ABSTAIN
+
+
+
+
+
+
+
+
+
+## Upregulator
+# Activator
+@labeling_function()
+def lf_activate(x):
+    return 3 if 'activat' in x.sentence.lower() else ABSTAIN
+
+@labeling_function()
+def lf_increase(x):
+    return 3 if 'increas' in x.sentence.lower() else ABSTAIN
+
+@labeling_function()
+def lf_induce(x):
+    return 3 if 'induc' in x.sentence.lower() else ABSTAIN
+
+@labeling_function()
+def lf_stimulate(x):
+    return 3 if 'stimulat' in x.sentence.lower() else ABSTAIN
+
+@labeling_function()
+def lf_upregulate(x):
+    return 3 if 'upregulat' in x.sentence.lower() else ABSTAIN
+
+
+
+
+
+
+
+
+
+
+
+
+## Downregulator
+@labeling_function()
+def lf_downregulate(x):
+    return 4 if 'downregulat' in x.sentence.lower() or 'down-regulat' in x.sentence.lower() else ABSTAIN
+
+@labeling_function()
+def lf_reduce(x):
+    return 4 if 'reduc' in x.sentence.lower() else ABSTAIN
+
+@labeling_function()
+def lf_inhibit(x):
+    return 4 if 'inhibit' in x.sentence.lower() else ABSTAIN
+
+@labeling_function()
+def lf_decrease(x):
+    return 4 if 'decreas' in x.sentence.lower() else ABSTAIN
+
+
+
+
+
+
+
+
+
+
+
+## Agonist
+@labeling_function()
+def lf_agonist(x):
+    return 5 if ' agoni' in x.sentence.lower() or "\tagoni" in x.sentence.lower() else ABSTAIN
+
+
+
+
+
+
+
+
+
+## Antagonist
+@labeling_function()
+def lf_antagonist(x):
+    return 6 if 'antagon' in x.sentence.lower() else ABSTAIN
+
+
+
+
+
+
+
+
+
+## Modulator
+@labeling_function()
+def lf_modulate(x):
+    return 7 if 'modulat' in x.sentence.lower() else ABSTAIN
+
+@labeling_function()
+def lf_allosteric(x):
+    return 7 if 'allosteric' in x.sentence.lower() else ABSTAIN
+
+
+
+
+
+
+
+
+
+## Cofactor
+@labeling_function()
+def lf_cofactor(x):
+    return 8 if 'cofactor' in x.sentence.lower() else ABSTAIN
+
+
+
+
+
+
+
+
+## Substrate/Product
+@labeling_function()
+def lf_substrate(x):
+    return 9 if 'substrate' in x.sentence.lower() else ABSTAIN
+
+@labeling_function()
+def lf_transport(x):
+    return 9 if 'transport' in x.sentence.lower() else ABSTAIN
+
+@labeling_function()
+def lf_catalyze(x):
+    return 9 if 'catalyz' in x.sentence.lower() or 'catalys' in x.sentence.lower() else ABSTAIN
+
+@labeling_function()
+def lf_product(x):
+    return 9 if "produc" in x.sentence.lower() else ABSTAIN
+
+@labeling_function()
+def lf_convert(x):
+    return 9 if "conver" in x.sentence.lower() else ABSTAIN
+
+
+
+
+
+
+
+
+
+## NOT
+@labeling_function()
+def lf_not(x):
+    return 10 if 'not' in x.sentence.lower() else ABSTAIN

classification/commercial/label.json

@@ -0,0 +1 @@
+{"0": 0, "1": 1}

classification/commercial/readme.txt

@@ -0,0 +1,22 @@
+Commercial
+
+# Source:
+
+D. Y. Fu, M. F. Chen, F. Sala, S. M. Hooper, K. Fatahalian, and C. Ré. Fast and three-rious: Speeding up weak supervision with triplet methods. In ICML, pages 3280–3291, 2020.
+
+
+# Labels:
+0: negative (the graph is not commercials)
+
+1: positive (the graph is  commercials)
+
+
+
+4 Labeling functions
+
+LFs: In this dataset, there is a strong signal for the presence or absence of commercials in pixel histograms and the text; in particular, commercials are book-ended on either side by sequences of black frames, and commercial segments tend to have mixed-case or missing transcripts (whereas news segments are in all caps). We use these signals to build the weak supervision sources.
+
+
+
+
+

classification/commercial/test.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c096f125a0d80437085a39795cde5e8b1a2147a2b22cad1b670b4f0bc54a675b
+size 322533732

classification/commercial/train.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27d25bb8c139e2ea14e619ca72c647d62dadb3645ab0e40325db4e1653827a25
+size 2761720065

classification/commercial/valid.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a67a253cdc2dddb8f838b1909e396fd78730a36e7244147608960017c885097
+size 407904603

classification/imdb/label.json

@@ -0,0 +1,4 @@
+{
+    "0": "Negative",
+    "1": "Positive"
+}

classification/imdb/readme.txt

@@ -0,0 +1,60 @@
+IMDB Sentiment Classification
+
+https://github.com/weakrules/Denoise-multi-weak-sources/tree/master/rules-noisy-labels/IMDB
+
+# Labels 
+
+"0": "Negative",
+"1": "Positive"
+
+
+# Labeling functions
+
+lfs = [
+    expression_nexttime,
+    keyword_compare,
+    keyword_general,
+    keyword_finish,
+    keyword_plot
+]
+
+
+# lf - expression_nexttime
+
+expression_nexttime = make_expression_lf(name="expression_nexttime", 
+    pre_pos=["will ", " ll ", "would ", " d ", "can t wait to "], 
+    expression=[" next time", " again", " rewatch", " anymore", " rewind"])
+    
+
+
+
+# lf - keyword_compare
+
+keyword_compare = make_keyword_lf(name="keyword_compare", 
+    keywords_pos=[], 
+    keywords_neg=[" than this", " than the film", " than the movie"])
+
+
+
+# lf - keyword_general
+
+keyword_general = make_keyword_lf(name="keyword_general", 
+    keywords_pos=["masterpiece", "outstanding", "perfect", "great", "good", "nice", "best", "excellent", "worthy", "awesome", "enjoy", "positive", "pleasant", "wonderful", "amazing", "superb", "fantastic", "marvellous", "fabulous"], 
+    keywords_neg=["bad", "worst", "horrible", "awful", "terrible", "crap", "shit", "garbage", "rubbish", "waste"])
+
+
+
+# lf - keyword_finish
+
+keyword_finish = make_keyword_lf(name="keyword_finish", 
+    keywords_pos=[], 
+    keywords_neg=["fast forward", "n t finish"])
+
+
+
+
+# lf - keyword_plot
+
+keyword_plot = make_keyword_lf(name="keyword_plot", 
+    keywords_pos=["well written", "absorbing", "attractive", "innovative", "instructive", "interesting", "touching", "moving"], 
+    keywords_neg=["to sleep", "fell asleep", "boring", "dull", "plain"])

classification/imdb/train.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c415ba520bb77b92f2dd3ba458c6a04ddffac03f506094cd24f25d1b9a28f21
+size 26860548