Merge pull request #132 from dwijenchawra/master

fixed issue #67 and #51

.github/workflows/TagBot.yml

@@ -1,11 +1,15 @@
 name: TagBot
 on:
- schedule:
- - cron: 0 * * * *
+ issue_comment:
+ types:
+ - created
+ workflow_dispatch:
 jobs:
  TagBot:
+ if: github.event_name == 'workflow_dispatch' || github.actor == 'JuliaTagBot'
  runs-on: ubuntu-latest
  steps:
  - uses: JuliaRegistries/TagBot@v1
  with:
  token: ${{ secrets.GITHUB_TOKEN }}
+ ssh: ${{ secrets.DOCUMENTER_KEY }}

.github/workflows/main.yml

@@ -16,7 +16,7 @@ jobs:
  with:
  version: '1.6'
  - name: Install LuaLatex
- run: sudo apt-get install texlive-full && sudo apt-get install texlive-latex-extra && sudo mktexlsr && sudo updmap-sys
+ run: sudo apt-get update && sudo apt-get install texlive-full --fix-missing && sudo apt-get install texlive-latex-extra && sudo mktexlsr && sudo updmap-sys
  - name: Install dependencies
  run: julia --project=docs/ -e 'using Pkg; Pkg.develop(PackageSpec(path=pwd())); Pkg.instantiate()'
  - name: Build and deploy

docs/make.jl

@@ -25,5 +25,6 @@ makedocs(
 )
 
 deploydocs(
- repo = "github.com/sisl/BayesNets.jl.git",
-)
+ repo = "github.com/dwijenchawra/BayesNets.jl.git",
+)
+return true

docs/src/usage.md

@@ -187,7 +187,7 @@ rand(bn_gibbs, gsampler, 5)
 
 BayesNets.jl supports parameter learning for an entire graph.
 
-```julia 
+```julia
 fit(BayesNet, data, (:a=>:b), [StaticCPD{Normal}, LinearGaussianCPD])
 ```
 
@@ -223,7 +223,7 @@ Inference methods for discrete Bayesian networks can be used via the `infer` met
 bn = DiscreteBayesNet()
 push!(bn, DiscreteCPD(:a, [0.3,0.7]))
 push!(bn, DiscreteCPD(:b, [0.2,0.8]))
-push!(bn, DiscreteCPD(:c, [:a, :b], [2,2], 
+push!(bn, DiscreteCPD(:c, [:a, :b], [2,2],
  [Categorical([0.1,0.9]),
  Categorical([0.2,0.8]),
  Categorical([1.0,0.0]),
@@ -283,7 +283,7 @@ data[1:3,:] # only display a subset...
 Here we use the K2 structure learning algorithm which runs in polynomial time but requires that we specify a topological node ordering.
 
 ```@example bayesnet
-parameters = K2GraphSearch([:Species, :SepalLength, :SepalWidth, :PetalLength, :PetalWidth], 
+parameters = K2GraphSearch([:Species, :SepalLength, :SepalWidth, :PetalLength, :PetalWidth],
  ConditionalLinearGaussianCPD,
  max_n_parents=2)
 bn = fit(BayesNet, data, parameters)
@@ -300,7 +300,7 @@ Changing the ordering will change the structure.
 
 ```julia
 CLG = ConditionalLinearGaussianCPD
-parameters = K2GraphSearch([:Species, :PetalLength, :PetalWidth, :SepalLength, :SepalWidth], 
+parameters = K2GraphSearch([:Species, :PetalLength, :PetalWidth, :SepalLength, :SepalWidth],
  [StaticCPD{Categorical}, CLG, CLG, CLG, CLG],
  max_n_parents=2)
 fit(BayesNet, data, parameters)
@@ -311,7 +311,7 @@ A `ScoringFunction` allows for extracting a scoring metric for a CPD given data.
 A `GraphSearchStrategy` defines a structure learning algorithm. The K2 algorithm is defined through `K2GraphSearch` and `GreedyHillClimbing` is implemented for discrete Bayesian networks and the Bayesian score:
 
 ```@example bayesnet
-data = DataFrame(c=[1,1,1,1,2,2,2,2,3,3,3,3], 
+data = DataFrame(c=[1,1,1,1,2,2,2,2,3,3,3,3],
  b=[1,1,1,2,2,2,2,1,1,2,1,1],
  a=[1,1,1,2,1,1,2,1,1,2,1,1])
 parameters = GreedyHillClimbing(ScoreComponentCache(data), max_n_parents=3, prior=UniformPrior())
@@ -325,7 +325,7 @@ TikzPictures.save(SVG("plot9"), plot) # hide
 
 We can specify the number of categories for each variable in case it cannot be correctly inferred:
 
-```julia
+```@example bayesnet
 bn = fit(DiscreteBayesNet, data, parameters, ncategories=[3,3,2])
 ```
 
@@ -338,11 +338,17 @@ A whole suite of features are supported for DiscreteBayesNets. Here, we illustra
 
 We also detail obtaining a bayesian score for a network structure in the next section.
 
-```julia
-count(bn, :a, data) # 1
-statistics(bn.dag, data) # 2
-table(bn, :b) # 3
-table(bn, :c, :a=>1) # 4
+```@example bayesnet
+count(bn, :a, data)
+```
+```@example bayesnet
+statistics(bn.dag, data)
+```
+```@example bayesnet
+table(bn, :b)
+```
+```@example bayesnet
+table(bn, :c, :a=>1)
 ```
 
 ## Reading from XDSL
@@ -363,12 +369,10 @@ TikzPictures.save(SVG("plot10"), plot) # hide
 The bayesian score for a discrete-valued BayesNet can can be calculated based only on the structure and data (the CPDs do not need to be defined beforehand). This is implemented with a method of ```bayesian_score``` that takes in a directed graph, the names of the nodes and data.
 
 ```@example bayesnet
-data = DataFrame(c=[1,1,1,1,2,2,2,2,3,3,3,3], 
+data = DataFrame(c=[1,1,1,1,2,2,2,2,3,3,3,3],
  b=[1,1,1,2,2,2,2,1,1,2,1,1],
  a=[1,1,1,2,1,1,2,1,1,2,1,1])
 g = DAG(3)
 add_edge!(g,1,2); add_edge!(g,2,3); add_edge!(g,1,3)
 bayesian_score(g, [:a,:b,:c], data)
 ```
-
-

src/BayesNets.jl

@@ -107,7 +107,9 @@ export
  adding_edge_preserves_acyclicity,
  bayesian_score_component,
  bayesian_score_components,
- bayesian_score
+ bayesian_score,
+
+ nodenames
 
 
 include("bayes_nets.jl")

src/DiscreteBayesNet/discrete_bayes_net.jl

@@ -71,15 +71,15 @@ function table(bn::DiscreteBayesNet, name::NodeName)
  d[!,name] = 1:ncategories(cpd(assignment))
  end
 
- p = ones(size(d,1)) # the probability column
+ potential = ones(size(d,1)) # the probability column
  for i in 1:size(d,1)
  assignment = Assignment()
  for j in 1:length(varnames)
  assignment[varnames[j]] = d[i,j]
  end
- p[i] = pdf(cpd, assignment)
+ potential[i] = pdf(cpd, assignment)
  end
- d[!,:p] = p
+ d[!,:potential] = potential
 
  return Table(d)
 end

src/DiscreteBayesNet/io.jl

@@ -157,8 +157,8 @@ function Base.write(io::IO, mime::MIME"text/plain", bn::DiscreteBayesNet)
  for name in arr_names
  cpd = get(bn, name)
  for D in cpd.distributions
- for p in probs(D)[1:end-1]
- str = @sprintf("%.16g", p)
+ for potential in probs(D)[1:end-1]
+ str = @sprintf("%.16g", potential)
  print(io, space ? " " : "" , str)
  space = true
  end

src/DiscreteBayesNet/tables.jl

@@ -2,7 +2,7 @@
 DataFrames are used to represent factors
 https://en.wikipedia.org/wiki/Factor_graph
 
- :p is the column containing the probabilities, ::Float64
+ :potential is the column containing the probabilities, ::Float64
  Each variable has its own column corresponding to its assignments and named with its name
 
 These can be obtained using the table() function
@@ -34,16 +34,16 @@ function Base.:*(t1::Table, t2::Table)
  f1 =t1.potential
  f2 =t2.potential
 
- onnames = setdiff(intersect(propertynames(f1), propertynames(f2)), [:p])
- finalnames = vcat(setdiff(union(propertynames(f1), propertynames(f2)), [:p]), :p)
+ onnames = setdiff(intersect(propertynames(f1), propertynames(f2)), [:potential])
+ finalnames = vcat(setdiff(union(propertynames(f1), propertynames(f2)), [:potential]), :potential)
 
  if isempty(onnames)
  j = join(f1, f2, kind=:cross, makeunique=true)
  else
  j = outerjoin(f1, f2, on=onnames, makeunique=true)
  end
 
- j[!,:p] = broadcast(*, j[!,:p], j[!,:p_1])
+ j[!,:potential] = broadcast(*, j[!,:potential], j[!,:potential_1])
 
  return Table(j[!,finalnames])
 end
@@ -57,25 +57,25 @@ function sumout(t::Table, v::NodeNameUnion)
  f = t.potential
 
  # vcat works for single values and vectors alike (magic?)
- remainingvars = setdiff(propertynames(f), vcat(v, :p))
+ remainingvars = setdiff(propertynames(f), vcat(v, :potential))
 
  if isempty(remainingvars)
  # they want to remove all variables except for prob column
  # uh ... 'singleton' table?
- return Table(DataFrame(p = sum(f[!,:p])))
+ return Table(DataFrame(potential = sum(f[!,:potential])))
  else
  # note that this will fail miserably if f is too large (~1E4 maybe?)
  # nothing I can do; there is a github issue
- return Table(combine(df -> DataFrame(p = sum(df[!,:p])), DataFrames.groupby(f, remainingvars)))
+ return Table(combine(df -> DataFrame(potential = sum(df[!,:potential])), DataFrames.groupby(f, remainingvars)))
  end
 end
 
 """
 Table normalization
-Ensures that the `:p` column sums to one
+Ensures that the `:potential` column sums to one
 """
 function LinearAlgebra.normalize!(t::Table)
- t.potential[!,:p] ./= sum(t.potential[!,:p])
+ t.potential[!,:potential] ./= sum(t.potential[!,:potential])
 
  return t
 end
@@ -103,23 +103,23 @@ end
 
 """
 takes a list of observations of assignments represented as a DataFrame
-or a set of data samples (without :p),
+or a set of data samples (without :potential),
 takes the unique assignments,
 and estimates the associated probability of each assignment
 based on its frequency of occurrence.
 """
 function Distributions.fit(::Type{Table}, f::DataFrame)
  w = ones(size(f, 1))
  t = f
- if hasproperty(f, :p)
- t = f[:, propertynames(t) .!= :p]
- w = f[!,:p]
+ if hasproperty(f, :potential)
+ t = f[:, propertynames(t) .!= :potential]
+ w = f[!,:potential]
  end
  # unique samples
  tu = unique(t)
  # add column with probabilities of unique samples
- tu[!,:p] = Float64[sum(w[Bool[tu[j,:] == t[i,:] for i = 1:size(t,1)]]) for j = 1:size(tu,1)]
- tu[!,:p] /= sum(tu[!,:p])
+ tu[!,:potential] = Float64[sum(w[Bool[tu[j,:] == t[i,:] for i = 1:size(t,1)]]) for j = 1:size(tu,1)]
+ tu[!,:potential] /= sum(tu[!,:potential])
 
  return Table(tu)
 end
@@ -133,8 +133,8 @@ end
 # n = size(f, 1)
 # p = zeros(n)
 # w = ones(n)
-# if hasproperty(f, :p)
-# w = f[!,:p]
+# if hasproperty(f, :potential)
+# w = f[!,:potential]
 # end
 #
 # dfindex = find([hasproperty(a, n) for n in names(f)])

src/Factors/factors_dims.jl

@@ -22,7 +22,7 @@ Normalize the factor so all instances of dims have (or the entire factors has)
 p-norm of 1
 """
 function LinearAlgebra.normalize!(ϕ::Factor, dims::NodeNameUnion; p::Int=1)
- dims = unique(convert(NodeNames, dims))
+ dims = unique(nodeconvert(NodeNames, dims))
  _check_dims_valid(dims, ϕ)
 
  inds = indexin(dims, ϕ)
@@ -69,7 +69,7 @@ Reduce dimensions `dims` in `ϕ` using function `op`.
 """
 function reducedim(op, ϕ::Factor, dims::NodeNameUnion, v0=nothing)
  # a (possibly?) more efficient version than reducedim!(deepcopy(ϕ))
- dims = convert(NodeNames, dims)
+ dims = nodeconvert(NodeNames, dims)
  _check_dims_valid(dims, ϕ)
 
  # needs to be a tuple for squeeze
@@ -85,7 +85,7 @@ function reducedim(op, ϕ::Factor, dims::NodeNameUnion, v0=nothing)
 end
 
 function reducedim!(op, ϕ::Factor, dims::NodeNameUnion, v0=nothing)
- dims = convert(NodeNames, dims)
+ dims = nodeconvert(NodeNames, dims)
  _check_dims_valid(dims, ϕ)
 
  # needs to be a tuple for squeeze
@@ -270,4 +270,3 @@ end
 /(ϕ1::Factor, ϕ2::Factor) = join(/, ϕ1, ϕ2)
 +(ϕ1::Factor, ϕ2::Factor) = join(+, ϕ1, ϕ2)
 -(ϕ1::Factor, ϕ2::Factor) = join(-, ϕ1, ϕ2)
-

src/Factors/factors_main.jl

@@ -5,6 +5,11 @@
 # THE MOST BASIC ASSUMPTION IS THAT ALL VARIABLES ARE CATEGORICAL AND THEREFORE
 # Base.OneTo WORTHY. IF THAT IS VIOLATED, NOTHING WILL WORK
 
+nodeconvert(::Type{NodeNames}, names::NodeNameUnion) = names
+
+nodeconvert(::Type{NodeNames}, name::NodeName) = [name]
+
+
 """
  Factor(dims, potential)
 
@@ -16,7 +21,7 @@ mutable struct Factor
  # In most cases this will be a probability
 
  function Factor(dims::NodeNameUnion, potential::Array{Float64})
- dims = convert(NodeNames, dims)
+ dims = nodeconvert(NodeNames, dims)
  _ckeck_dims_unique(dims)
 
  (length(dims) != ndims(potential)) &&
@@ -192,4 +197,3 @@ function pattern(ϕ::Factor)
  hcat([repeat(collect(1:l), inner=i, outer=o) for (l, i, o) in
  zip(lens, inners, outers)]...)
 end
-

src/Inference/exact.jl

@@ -9,7 +9,7 @@ function infer(im::ExactInference, inf::InferenceState{BN}) where {BN<:DiscreteB
  nodes = names(bn)
  query = inf.query
  evidence = inf.evidence
- hidden = setdiff(nodes, vcat(query, names(evidence)))
+ hidden = setdiff(nodes, vcat(query, keys(evidence)))
 
  factors = map(n -> Factor(bn, n, evidence), nodes)
 
@@ -31,4 +31,3 @@ function infer(im::ExactInference, inf::InferenceState{BN}) where {BN<:DiscreteB
 end
 infer(inf::InferenceState{BN}) where {BN<:DiscreteBayesNet} = infer(ExactInference(), inf)
 infer(bn::BN, query::NodeNameUnion; evidence::Assignment=Assignment()) where {BN<:DiscreteBayesNet} = infer(ExactInference(), InferenceState(bn, query, evidence))
-