Getting started

In this introductory section, you will learn about the main building blocks of ModalAssociationRules.jl. Also, if a good picture about association rule mining (ARM, from now onwards) is given during the documentation, to make the most out of this guide, we suggest reading the following articles:

The above introduces two important algorithms, which are also built into this package. Moreover, the latter one is the state-of-the-art in the field of ARM.

Further on in the documentation, the potential of ModalAssociationRules.jl will emerge: this package's raison d'être is to generalize the already existing ARM algorithms to modal logics, which are more expressive than propositional ones (as it allows to reason in terms of relational data) and computationally less expensive than first-order logic. If you are new to Sole.jl and you want to learn more about modal logic, please have a look at SoleLogics.jl for a general overview on the topic, or follow this documentation and return to the link if needed.

Fast introduction

Consider a time series dataset. For example, let us consider the NATOPS dataset, obtained by recording the movement of different body parts of an operator. We are interested in extracting temporal considerations hidden in the data. To do so, we can highlight specific intervals in each time series (we assume every signal to have the same length). For example, consider the following time series encoding the vertical trajectory of the right hand of an operator.

I have command movement, specifically the right hand y-axis of the operator

Now, we can highlight different intervals on the signal. For example, via windowing:

1st window of the signal above. 2nd window of the signal above. 3rd window of the signal above. 4th window of the signal above. 5th window of the signal above.

At this point, we can define a set of logical facts (Items in the jargon) to express a particular property of each interval. We are interested in extracting complex associations hidden in data. In this case, we need a logical formalism capable of capturing temporal relations between different intervals. In particular, HS Interval Logic comes in handy to establish relations such as "the item p holds on the interval X, while the item q holds on the interval Y, and Y comes after X".

What we want to do, in general, is to extend propositional logic with a specific modal logic formalism (hence, the name of this package) that lets us reason in terms of dimensional relations in data while, at the same time, is not as computationally expensive as first order logic.

To provide you with a more concrete example, consider the following two items, called p and q. We define them as if we were in the Julia REPL.

# ScalarCondition is a "generic comparison strategy" defined in SoleData.jl; it says that the maximum in an object encoding a piece of the first variable (in the example above, the right hand vertical movement) must be greater than the threshold 0.5. 

# Atom is a wrapper provided by SoleLogics.jl, to later establish the truth value of a structure.
p = ScalarCondition(VariableMin(1), <, -1.0) |> Atom

# This fact is true on the intervals [1:10] and [11:20] in the example above.
q = ScalarCondition(VariableMax(1), >=, 0.0) |> Atom

# IA_A is the After relation of Allen's interval algebra; "diamond" is one of two modalities (the other one is called "box"); we can ignore it for simplicity here.
ap = diamond(IA_A)(p)

alphabet = [p,q,ap]

Note that the example provided, although concrete, is still a toy example as each interval is completely flattened to just one scalar value. In practice, we would like to deal with more expressive kinds of ScalarCondition.

Now that we have arranged an alphabet of items, we want to establish which items co-occur together by computing the relative frequency of every possible combination of items (this is the most naive mining strategy, but, at the moment, let us forget about performance). Item combinations are called itemsets, and the relative frequency of how many times an itemset is true within the data is typically called support.

Itemset	[1:10]	[11:20]	[21:30]	[31:40]	[41:50]	Support
[p]	true	true	true		true	4/5
[q]			true	true	true	3/5
[ap]	true	true		true		3/5
[p,ap]	true	true				2/5
[q,ap]			true		true	2/5
[p,q,ap]						0/5

Note that the relative frequency decreases as the itemset we consider gets bigger. Also, note how the after operator in ap shifts the truth values of p one space to the left in the table; in this sense, a temporal declination of a fact is simply a special mask of bits obtained by the fact itself.

Let us say that we want to consider the itemset [p,ap] to be frequent, that is, we consider its support to be high enough. The support for an itemset could be very high because it expresses a triviality, so we want to further process the itemset and better analyze it via specific meaningfulness measures.

In particular, we could consider the two rules [p] => [ap] and [ap] => [p]. If they turn out to be meaningful to us, then we call such rules association rules.

The high-level pipeline we described should be useful to proceed with reading the rest of the documentation.

Core definitions

One Item is just a logical formula, which can be interpreted by a certain model. At the moment, here, we don't care about how models are represented by Sole.jl under the hood, or how the checking algorithm works: what matters is that Items are manipulated by ARM algorithms, which try to find which conjunctions between items are most statistically significant.

ModalAssociationRules.Item — Type

struct Item{F<:SoleLogics.Formula}
    formula::F
end

Fundamental type in the context of association rule mining.

The name Item comes from the classical association rule mining jargon, but it is simply a wrapper around a logical formula, whose truth value can be checked on a model. To know more about logical formulas, see SoleLogics.Formula.

Getting started

Fast introduction

Core definitions

Measures

Mining structures

Miner customization

Parallelization