Introduction To Hidden Markov Models

Posted on Updated on

A Hidden Markov Model is a statistical model that can be used to determine the underlying processes that affect a particular observed outcome. A HMM can be presented as the simplest dynamic Bayesian network. The mathematics behind the HMM were developed by L. E. Baum and coworkers. It is closely related to an earlier work on the optimal nonlinear filtering problem by Ruslan L. Stratonovich, who was the first to describe the forward-backward procedure.

In simpler Markov models (like a Markov chain), the state is directly visible to the observer, and therefore the state transition probabilities are the only parameters. In a hidden Markov model, the state is not directly visible, but the output, dependent on the state, is visible. Each state has a probability distribution over the possible output tokens. Therefore, the sequence of tokens generated by an HMM gives some information about the sequence of states. The adjective ‘hidden’ refers to the state sequence through which the model passes, not to the parameters of the model; the model is still referred to as a ‘hidden’ Markov model even if these parameters are known exactly.

Example:
Consider two friends, Alice and Bob, who live far apart from each other and who talk together daily over the telephone about what they did that day. Bob is only interested in three activities: walking in the park, shopping, and cleaning his apartment. The choice of what to do is determined exclusively by the weather on a given day. Alice has no definite information about the weather where Bob lives, but she knows general trends. Based on what Bob tells her he did each day, Alice tries to guess what the weather must have been like.

states = ('Rainy', 'Sunny')
observations = ('walk', 'shop', 'clean')
start_probability = {'Rainy': 0.6, 'Sunny': 0.4}
transition_probability = {
                           'Rainy': {'Rainy': 0.7, 'Sunny': 0.3}
                           'Sunny': {'Rainy': 0.4, 'Sunny': 0.6}
                         }
emission_probability = {
                         'Rainy': {'walk': 0.1, 'shop': 0.4, 'clean': 0.5}
                         'Sunny': {'walk': 0.6, 'shop': 0.3, 'clean': 0.1}
                       }

Implementation in Python:
implementation

References:
hmmlearn
wikipedia

Activate Virtual Environment In PyCharm

Posted on Updated on

I create python projects so infrequently that whenever I need to create a new project or add a package to my Python base project I completely forget how to do it; so here goes…

In the terminal window of Pycharm type: source activate [environment-name]
conda

Then you can pip install the package info your environment
wheel

The end.

Single Linked List -Python

Posted on

My practice implementation of a single linked list in Python.

class Node:
    def __init__(self, value):
        self.next = None
        self.value = value

class List:
    def __init__(self, value):
        self.head = Node(value)

    def insert(self, value):
        current = self.head
        while current.next is not None:
            current = current.next
        current.next = Node(value)

    def find(self, value):
        current = self.head
        while current is not None:
            if current.value == value:
                return True
            else:
                current = current.next
        return False

    def delete(self, value):
        if self.find(value) is not True:
            return "Not in list"
        else:
            current = self.head
            while current is not None:
                if current.next.value == value:
                    current.next = current.next.next
                    break
                else:
                    current = current.next

    def print(self):
        current = self.head
        while current is not None:
            if current.value is not None:
                print(current.value)
            current = current.next

v = List(None)

v.insert(10)
v.insert(20)
v.insert(30)
v.print()
print("---")
v.delete(20)
v.print()

Using The Master Theorem To Find the Big O Of Recursive Algorithms

Posted on Updated on

For some persons finding the Big O of recursive algorithms can prove to be difficult especially if the algorithms are complexed. The Master Theorem provides a relatively simple way to solve recurrence relations as long as the recurrence fits the theorem constraints.

Basic definition:
T(n) = aT(n/b) + f(nc) where a >= 1, b > 1, and c >= 1
T(n) = Θ(nc) if c >= logba
T(n) = Θ(nc log n) if c = logba
T(n) = Θ(nlogba) if c < logba

We can think of “b” as the number of branches and “a” as the number of recurrences done; lets take a look at the example.

If we have a function:

def binary_search(seq, value):
    if len(seq) == 0:
        return False
    else:
        mid = len(seq) // 2
        if value == seq[mid]:
            return True
        elif value < seq[mid]:
            return binary(seq[:mid], value)
        elif value > seq[mid]:
            return binary(seq[mid + 1:], value)

T(n) = 2T(n/1) + f(n0) : a = 1, b = 2, c = 0

log21 = 0 therefore c = logba which satisfies Θ(nclog n) = O(log n)

References:
anupcowkur.com
wikipedia.com

Monads And Their Applications in C#

Posted on Updated on

If you have ever written code in most modern programming languages and even languages that are not functional in nature there is a very high probability that you have used some form of monadic structure. A monad is a structure that represents computations defined as sequences of steps: a type with a monad structure defines what it means to chain operations, or nest functions of that type together. This allows the programmer to build pipelines that process data in steps, in which each action is decorated with additional processing rules provided by the monad. As such, monads have been described as “programmable semicolons”.

Monads allow you to do things like method chaining, and flattening null and exception checks in highly nested code blocks.

Monadic Rules:

1.  Left identity
Identity.Compose(f) = f

2.  Right identity
f.Compose(Identity) = f

3.  Associative
f.Compose(g.Compose(h)) = (f.Compose(g)).Compose(h)

Example: Very basic Monad to factor out division by zero check in BMI calculation.

void Main()
{
    var me = new person{name = "Romaine", weight = 170, height = 83};
    Console.WriteLine(new Maybe<int>(me.height).bind(() => new Maybe<int>((703 * me.weight) / (me.height * me.height))));
}

class Maybe<T>
{
    public T value;
 
    public Maybe(T val)
    {
        value = val;
    }
 
    public Maybe<T> bind(Func<Maybe<T>> func)
    {
        if(value == null || value.Equals(0))
            return null;
        return func();
    }
}


class person 
{
    public string name;
    public int weight;
    public int height;
}

Monads are awesome, and I still have a lot to learn about them, however I can already see them everywhere in C#: IEnumerable, JQuery: Ajax Requests and lots more.

Until next time keep learning🙂

References:
blogs.msn.com
wikipedia.org

From MATLAB To Python

Posted on

MATLAB:

For many years MATLAB has been my primary tool for prototyping algorithms, because of its rich set of optimization functions and the AI tool box it has proven to be a valuable tool to have. However, It is not cheap and if you do not have a company to pay for license or attend a university that provides you with a license then you will have to find an alternative.

MATLAB is not a programming language rather its a tool that has as part of its framework a programming language called M language, this language has a lot of quirks and takes some getting use to, the other issue I found with MATLAB is that the functions while well documented do not seem to follow a standard in terms of parameters; on the whole while MATLAB is a good tool for prototyping and is used a lot in engineering and medical fields which are my core domain; However,I am forced to look for a cheaper/free alternative that will give me as much if not more tools than MATLAB now provides.

Python to the rescue:

Python is powerful… and fast;
plays well with others;
runs everywhere;
is friendly & easy to learn;
is Open

All these wonderful things make Python a big contender for my MATLAB replacement.

The first thing we want to do is install Python.
Next install my favurite Python IDE PyCharm
Create a new Python Project using PyCharm
Python project

How do we add packages to our project?
Python is nothing without its packages and two of my favourites are numpy and scipy. To add these packages simply download the Anaconda distribution and configure it to be your default python implementation.

pylibs

And here is my first piece of python code as taken from the python website🙂

pyresult

All I need now is a good Python book and 2-4 months to delve into the language. Stay tuned for more posts on my Python journey. Happy coding!!

Finding stuff in SVN Source control with PowerShell

Posted on Updated on

Its as simple as this:

svn list -R [your svn repo url] | select-string [string to search for]