Solved – How to predict employee’s attendance based on previous attendance

The example I'm about to give avoids the use of proper sequence learning and instead goes for a simple and hopefully more intuitive attribute-value approach based on the Naive Bayes estimator. There are more advanced ways of solving this but from reading your question I think the approach I'm about to present is more appropriate.

So given what we know about the previous sequence, we want to learn as much as possible about what is about to follow. Let's take the following sequence [1,0,1,1,0,1,0,1,1,0,1]:

Based on the last value, 1, we can say that in 4 out of 6 cases, a 0 will follow. The same can be done for the previous 2 values, 0,1; these are in 2 out of 3 cases followed by a 1. The same can be said about the previous 3 values, 1,0,1, which are in 2 out of 3 cases followed by a 1. Now looking at the previous 4 values 1,1,0,1 we can finally state that this will always be followed by a 0,idem for the previous 5 and 6. We don't know anything about the previous 7 as they have not been seen before. A natural conclusion is thus the follow the prediction based on the most certain predictions based on the previous 4,5 and 6 values and state that 0 be the next value.

One can thus parse all patterns of length n from the sequence:

def parse(history, n):     for i in range(len(history) - n):         yield (history[i:i + n], history[i + n]) 

Which will yield for n=3:

[([1, 0, 1], 1),  ([0, 1, 1], 0),  ([1, 1, 0], 1),  ([1, 0, 1], 0),  ([0, 1, 0], 1),  ([1, 0, 1], 1),  ([0, 1, 1], 0),  ([1, 1, 1], 1)] 

Next step is to learn from these patterns how many times a certain pattern is followed by 1 or 0

def learn(example, n):     occurences = parse(example, n)     # counts[followed_by][pattern]     counts = [[0] * pow(2, n), [0] * pow(2, n)]     # loop over all occurences     for occurence in occurences:         pattern, followed_by = occurence         pattern_hash = hash(pattern)         counts[followed_by][pattern_hash] += 1     return counts 

In the above we hash each pattern into the its binary value for convenience. We can now determine the probability the previous-n values (i.e. last n-values of our example) are followed by a 1

def probability(example, n):     counts = learn(example, n)     # determine probability that 1 will follow after `previous`     # (last n values), using what we know about past values     previous = example[-n:]     previous_hash = hash(previous)     # Determine probability of `followed_by`=1     total_count = (counts[1][previous_hash] + counts[0][previous_hash])     # if pattern was never (`total_count` == 0) seen return None     return counts[1][previous_hash] / total_count if total_count else None 

The last step is to make a prediction based on the most certain prediction between the different pattern lengths n from the previous step. probability([1,0,1,1,0,1,0], 3) will return None as 0,1,0 has never been observed, probability([1,0,1,1,0,1,0], 2) will return 3/4.

def prediction(example):     max_n = len(example) - 1     # Determine probability of `followed_by`=1 over different pattern lengths     probabilities = [(probability(example, n), n) for n in range(1, max_n) if probability(example, n) is not None]     # If min equals 0, there is a pattern that is inconsistent with next being 1     p = min(probabilities)[0] and max(probabilities)[0]     n = [n for pp, n in probabilities if pp==p][0]     most_informative = example[-n:] + [int(p)]     return (p, most_informative) 

When one of the probabilities equals zero, which means that a 1 would be fully inconsistent with a certain pattern, the probability is zero. When one of the probabilities equals one, this means that a 1 is in perfect agreement with a certain pattern and the probability for 1 is thus one.

As an extra feature the last step will also give the most informative pattern, in the case of equal importance, the shortest is returned. The following tests show it in action:

tests = [([0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0], 1),          ([1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0], 1),          ([1, 1, 0, 1, 0, 0, 1], 0),          ([1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0], 1)] # run tests for test in tests:     pattern, expectation = test     outcome, mi = prediction(pattern)     test_outcome = "CORRECTLY" if outcome == expectation else "INCORRECTLY"     print("Predicted", int(outcome),           test_outcome,"for", pattern, ", pattern:", mi)  >>> Predicted 1 CORRECTLY for [0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0] , pattern: [0, 1] >>> Predicted 1 CORRECTLY for [1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0] , pattern: [0, 1] >>> Predicted 0 CORRECTLY for [1, 1, 0, 1, 0, 0, 1] , pattern: [0, 1, 0] >>> Predicted 1 CORRECTLY for [1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0] , pattern: [0, 1, 0, 1] 

The full code can be found in this gist