ruleminer 0.1.0

Installation

To install the package:

pip install ruleminer

To install the package from Github:

pip install -e git+https://github.com/wjwwillemse/ruleminer.git#egg=ruleminer

To use ruleminer in a project:

import ruleminer

Examples

Generating rules

Evaluate the expression

if ({"T.*"} == ".*") then ({"TV.*"} > 0)

with the insurance data DataFrame above:

templates = [{'expression': 'if ({"T.*"} == ".*") then ({"TV.*"} > 0)'}]
r = ruleminer.RuleMiner(templates=templates, data=df)

This will generate the following rules (available with r.rules):

You can define so-called rule templates that contain regular expressions for column names and strings. The package will then generate rules that satisfy the rule template with matching column names and strings from the data DataFrame. For example, given the data DataFrame above, column regex:

{"T.*"}

will satisfy column names:

{"Type"}, {"TP-life"}, {"TP-nonlife"}

Rule pruning

By using regex in column names, it will sometimes happen that rules are identical to other rules, except that they have a different ordering of columns. For example:

max({"TP life"}, {"TP nonlife"})

is identical to:

max({"TP nonlife"}, {"TP life"})

The generated rules are therefore pruned to delete the identical rules from the generated list of rules.

• a==b is identical to b==a

• a!=b is identical to b!=a

• min(a, b) is identical to min(b, a)

• max(a, b) is identical to max(b, a)

• a+b is identical to b+a

• a*b is identical to b*a

These identities are applied recursively in rules. So the rule:

(({"4"}>{"3"}) & (({"2"}+{"1"})=={"0"}))

is identical to:

((({"1"}+{"2"})=={"0"}) & ({"4"}>{"3"}))

and will therefore be pruned from the list if the latter rule is already in the list.

Rule template grammar

The rule template describes the structure of the rule. Columns and quoted strings in the rule template can contain simple regular expressions.

Examples:

{"Assets"} > 0

if ({"Type"} == "life insurer") then ({".*"} > 0)

if ({".*"} > 0) then (({".*"} == 0) & ({".*"} > 0))

The syntax of the template follows a grammar defined as follows:

• a template is of the form:

  if cond_1 then cond_2

  or simply a single:

  cond_1

• a condition is either a combination of comparisons with logical operators (’&’, ‘and’, ‘|’, ‘or’) and parenthesis:

  ( comp_1 & comp_2 | comp_3 )

  or simply a single comparison:

  comp_1

• a comparison consists of a term, a comparison operator (>=, >, <=, <, != or ==) and a term, so:

  term_1 > term_2

• a term can be a number (e.g. 3.1415 or 9), quoted string (a string with single or double quotes), or a function of columns

• a function of columns is either a prefix operator (min, max, abs or sum, in lower or uppercase) on one or more columns, and of the form, for example:

  min(col_1, col_2, col_3)

  or infix operators with one or more columns:

  (col_1 + col_2 * col_3)

• a column is a string with braces, so:

  {"Type"}

  where “Type” is the name of the column in the DataFrame with the data

• a string consists of a-z A-Z 0-9 _ . , ; ; < > * = + - / ? | @ # $ % ^ & ( )