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

Minimal complete definition

addVertex, removeVertex, vertexValue, changeVertexValue, someVertex, hasNoVertices, allVertices, allVertexValues, allNodes, isLinkedWithAnEdge, addEdge, removeEdge, edgeVertices, edgeValue, someEdge, hasNoEdges, allEdges, allEdgeValues, emptyGraph, oriented, neighbors

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

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)

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)

Functor (GraphMonad g e f)

Applicative (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

BayesianVariable Vertex

data Edge

Edge type used to identify and edge in a graph

Instances

Eq Edge

Ord Edge

Show 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