Bayes

Bayesian Network Library.

It is a very preliminary version. It has only been tested on very simple examples where it worked. It should be considered as experimental and not used in any production work.

• Look at the Bayes.Examples and Bayes.Examples.Tutorial in this package to see how to use the library.
• In Bayes.Examples.Influence you'll find additional examples about influence diagrams.
• In Bayes.Examples.Sampling there are some explanations about the samplers for discrete networks.
• Bayes.Examples.EMTest is explaining learning with expectation / maximization.
• Bayes.Examples.ContinuousSampling is showing an example of sampling with a continuous network.

Graph

Graph classes

class Graph g where

Graph class used for graph processing algorithms. A graph processing algorithm does not have to know how the graph is implemented nor if it is directed or undirected

Methods

addVertex :: Vertex -> b -> g a b -> g a b

Add a new vertex

removeVertex :: Vertex -> g a b -> g a b

Remove a vertex

vertexValue :: g a b -> Vertex -> Maybe b

Get the vertex value if the vertex is found in the graph

changeVertexValue :: Vertex -> b -> g a b -> Maybe (g a b)

Change the vertex value if the vertex is found in the graph

someVertex :: g a b -> Maybe Vertex

Generate a "random" vertex

hasNoVertices :: g a b -> Bool

Check is the graph has no vertrex

allVertices :: g a b -> [Vertex]

Generate all vertices

allVertexValues :: g a b -> [b]

Get all the values

allNodes :: g a b -> [(Vertex, b)]

Get all nodes

isLinkedWithAnEdge :: g a b -> Vertex -> Vertex -> Bool

Check if two vertices are linked by a vertex

addEdge :: Edge -> a -> g a b -> g a b

Add an edge

removeEdge :: Edge -> g a b -> g a b

Remove an dedge

edgeVertices :: g a b -> Edge -> Maybe (Vertex, Vertex)

Vertices for an edge

edgeValue :: g a b -> Edge -> Maybe a

Edge value if the edge is found in the graph

someEdge :: g a b -> Maybe Edge

Return a "random" edge

hasNoEdges :: g a b -> Bool

Check if the graph has no edges

endVertex :: g a b -> Edge -> Maybe Vertex

One extremity of the edge (which is the end only for directed edge)

startVertex :: g a b -> Edge -> Maybe Vertex

One extremity of the edge (which is the start only for directed edge)

allEdges :: g a b -> [Edge]

All edges of the graph

allEdgeValues :: g a b -> [a]

All values of the graph

emptyGraph :: g a b

Returns an empty graph

isEmpty :: g a b -> Bool

Check if the graph is empty

oriented :: g a b -> Bool

Check if the graph is oriented

neighbors :: g a b -> Vertex -> Maybe [Vertex]

All the neighbors of a vertex

Instances

Graph UndirectedSG

SimpleGraph is an instance of Graph.

Graph DirectedSG

SimpleGraph is an instance of Graph.

class Graph g => UndirectedGraph g where

Undirected graph

Methods

edges :: g a b -> Vertex -> Maybe [Edge]

Instances

UndirectedGraph UndirectedSG

class Graph g => DirectedGraph g where

Directed graph

Methods

ingoing :: g a b -> Vertex -> Maybe [Edge]

outgoing :: g a b -> Vertex -> Maybe [Edge]

Instances

DirectedGraph DirectedSG

class FoldableWithVertex g where

The foldable class is limited. For a graph g we may need the vertex in addition to the value

Methods

foldrWithVertex :: (Vertex -> a -> b -> b) -> b -> g c a -> b

Fold with vertex

foldlWithVertex' :: (b -> Vertex -> a -> b) -> b -> g c a -> b

Instances

FoldableWithVertex (SimpleGraph local)

class FunctorWithVertex g where

Methods

fmapWithVertex :: (Vertex -> a -> b) -> g c a -> g c b

fmapWithVertexM :: Monad m => (Vertex -> a -> m b) -> g c a -> m (g c b)

Instances

FunctorWithVertex (SimpleGraph local)

class Graph g => NamedGraph g where

A named graph is a graph where the vertices have a name. This name is not a vertex value. Putting this name in the vertex value would make algorithm less readable. A vertex name is only useful to display the graph. Labeled graph has a different meaning in graph theory.

Methods

addLabeledVertex :: String -> Vertex -> b -> g a b -> g a b

Add a vertex with a vertex name in addition to the value

vertexLabel :: g a b -> Vertex -> Maybe String

Returns the vertex label

Instances

NamedGraph UndirectedSG

NamedGraph DirectedSG

Graph Monad

data GraphMonad g e f a

Graph monad. The monad used to simplify the description of a new graph g is the graph type. e the edge type. f the node type (generally a Factor)

Instances

Monad (GraphMonad g e f)

MonadState (GMState g e f) (GraphMonad g e f)

type GMState g e f = (AuxiliaryState, g e f)

The state of the graph monad : the graph and auxiliary data useful during the construction

graphNode :: NamedGraph g => String -> f -> GraphMonad g e f Vertex

Add a node in the graph using the graph monad

runGraph :: Graph g => GraphMonad g e f a -> (a, g e f)

execGraph :: Graph g => GraphMonad g e f a -> g e f

evalGraph :: Graph g => GraphMonad g e f a -> a

emptyAuxiliaryState :: (Map k a, Int)

getNewEmptyVariable :: NamedGraph g => Maybe String -> f -> GraphMonad g e f Vertex

Generate a new unique unamed empty variable

isRoot :: DirectedGraph g => g a b -> Vertex -> Bool

rootNode :: DirectedGraph g => g a b -> Maybe Vertex

Get the root node for the graph

parentNodes :: DirectedGraph g => g a b -> Vertex -> [Vertex]

Return the parents of a node

childrenNodes :: DirectedGraph g => g a b -> Vertex -> [Vertex]

Return the children of a node

markovBlanket :: DirectedGraph g => g a b -> Vertex -> [Vertex]

Return the Markov blanket of a node

Support functions for Graph constructions

data Vertex

Vertex type used to identify a vertex in a graph

Instances

Eq Vertex

Ord Vertex

Show Vertex

Binary Vertex

BayesianVariable Vertex

data Edge

Edge type used to identify and edge in a graph

Instances

Eq Edge

Ord Edge

Show Edge

Binary Edge

edge :: Vertex -> Vertex -> Edge

Create an edge description

newEdge :: Graph g => Vertex -> Vertex -> e -> GraphMonad g e f ()

Add a new labeled edge to the graph

getVertex :: Graph g => String -> GraphMonad g e f (Maybe Vertex)

Get a named vertex from the graph monad

edgeEndPoints :: Edge -> (Vertex, Vertex)

Endpoints of an edge

connectedGraph :: Graph g => g a b -> Bool

Check if the graph is connected

dag :: DirectedGraph g => g a b -> Bool

Check if the graph is a directed Acyclic graph

printGraphValues :: (Graph (SimpleGraph n), Show b) => SimpleGraph n e b -> IO ()

Print the values of the graph vertices

SimpleGraph implementation

The SimpleGraph type

type DirectedSG = SimpleGraph DE

Directed simple graph

type UndirectedSG = SimpleGraph UE

Undirected simple graph

type SBN f = DirectedSG () f

An implementation of the BayesianNetwork using the simple graph and no value for the edges

varMap :: SimpleGraph n e v -> Map String Vertex

Get the variable name mapping

displaySimpleGraph :: (Vertex -> n -> Maybe String) -> (Vertex -> n -> Maybe String) -> (Edge -> e -> Maybe String) -> (Edge -> e -> Maybe String) -> SimpleGraph local e n -> String

Bayesian network

type BayesianNetwork g f = g () f

Bayesian network. g must be a directed graph and f a factor

Testing

testEdgeRemoval_prop :: DirectedSG String String -> Property

testVertexRemoval_prop :: DirectedSG String String -> Property