RNetica is best thought of as a "glue" layer between the open source statistical programming language R http://www.r-project.org/ and the proprietary Bayesian network engine Netica ® http://www.norsys.com/. Although there are some minor extensions to the Netica API, the primary purpose of RNetica is to provide a binding for the Netica API functions inside of R.
There are two big advantages to this. One is that while the Netica GUI is helpful for model development, entering evidence by point and click is cumbersome for real work. Embedding the Netica API within R means that R can be used for data preparation and cleaning, the data can be entered into a model developed with the Netica GUI and the results extracted and graphed using the graphical power of R. The second big advantage is that R is an interpreted language, which supports rapid improvisation of code. This make it substantially faster to work in RNetica than using the C or Java APIs.
pkg-config
the NETICA_HOME
environmental variable, or the --with-netica
argument to the installer.arm64e
Macs. I've raised the issue with Norsys, but have not yet gotten a response.options("NeticaLicenseKey")
to the value obtained from Norsys.pkg-config
for determining the
location of the Netica headers and libraries. See the
INSTALLATION file for details. AbsorbNodes
function.
Basically, Netica will crash if some nodes have visual
information and others do not. When Norsys fully releases
version 6, this should be fixed. Until then, either make sure
that all or none of the nodes
have visual information.[]
and [[]]
opertators are used in a way that breaks
backwards compatability. The []
operator
is used to manipulate CPTs for probabilistic nodes and
the [[]]
operator is used to manipulate value tables
for deterministic (logical) nodes.
[[]]
and []
operators work. Now [
and [<-
always
manipulate CPTs for probabilistic nodes. This should fix a
problem with being unable to use the []
to set CPTs
for continuous nodes that have been discritized. [[
and [[<-
operators now focus
on manipulating the the value tables for deterministic nodes.[[...]]
expression is no longer a synnonmym
for [[...,drop=TRUE]]
. This may break some code but
it should be straightforward to fix.testNetwork
function which can be used
to calculate evidentiary power of the networks.str
, which
generates a warning in RStudio. This is harmless, but I'll
add str
methods in the future.NeticaSession
object as a
container for the link to the Netica session. This also serves as a
container for all of the networks included in a session and a
wrapper for the license key.DefaultNeticaSession
in the global
environment is referenced.NeticaSession
as
an argument. These include the high level
functions CreateNetwork
, GetNthNetwork
,
GetNamedNetworks
, and ReadNetworks
. A
session argument is also needed by some lower level functions which
create Netica objects:
CaseFileDelimiter
, CaseFileMissingCode
,
CaseFileStream
, CaseMemoryStream
,
OpenCaseStream
and NewNeticaRNG
.
In all cases, if no session argument is supplied the value
of DefaultNeticaSession
is used instead.NeticaSession
,
NeticaBN
, NeticaNode
, CaseStream
,
and NeticaRNG
are now R reference classes (a special
case of S4 classes) instead of strings with with attributes
including an S3 class string. This should prove more robust as
certain R functions (in particular, c()
) which
stripped the attributes.
as.character
for networks and
nodes now returns a string of the
form <Type: Name>
instead of
the name of the object. Use the
expression obj$Name
to get the name of the
object. as.character
has
unexpected results when applied to a list of nodes (or
presumably nets). In stead of recursively applying the
proper as.character
method for the class, it
applies a default method which returns <S4 object of
type \"NeticaNode">
.
Use sapply(nodelist,NodeName)
instead.match(node, nodelist)
no
longer works as expected. This appears to be a bug in R
as match
turns objects into strings before
matching, but the bug in as.character
when applied
to a list produces unexpected results.
Use match(node,
sapply(nodelist,NodeName))
instead.NodeParent
) would sometimes
return a non-R object (e.g., FALSE
). In the new system
network objects are cached in the NeticaSession
object
and node objects are cached in the NeticaBN
object.
$nets
in the NeticaSession
object. This can be used in a read-only way by RNetica users.
In particular, session$nets$netname
,
where netname is the Netica name of the network, can be
used to reference a network in a session.$nodes
in the NeticaBN
object. Again, this can be used
in a read-only way,
e.g., net$nodes$nodename
.CreateNetwork
) or read into RNetica
(ReadNetworks
). R objects are only created and
registered with the cache in the network when first accessed.
Calling the function NetworkAllNodes
on the network
will create R objects for all nodes in the network and register
them. CaseStream
object is now an abstract class,
with two concrete subclasses: FileCaseStream
and MemoryCaseStream
. Again, these are now
represented as reference class objects and not strings with
attributes, so they should be more robust.
CaseFileStream()
and CaseMemoryStream()
(note that the name of the
constructor is not the name of the class) require a session
attribute.MemoryCaseStream
has been renamed
name from "CaseSMemorytreamm". The constructor is
still CaseMemoryStream()
(this now matches the
pattern used for FileCaseStream
).MemoryCaseStream
objects with some RNetica
functions (notably LearnCPTs
). For the moment,
it is safer to stick with the files which seem to work better.
CaseStream
objectsWithOpenCaseStream
to ensure closure.startSession()
, stopSession()
and restartSession()
(which take a session object as an
argument) handle this.
session <-
NeticaSession(LicenseKey="keystring")
followed by
startSession(session)
. If session
is an object stored in the R global workspace, the first step
only needs to be executed the first time RNetica is used, the
second will be available thereafter.StartNetica
creates a new Netica
session and starts it. The function StopNetica
stops the default session (unless given an argument).DefaultNeticaSession
to the
session object. The function getDefaultSession()
provides the default for most functions where a session argument
is required. This uses the value
of DefaultNeticaSession
, starting it if it is
currently closed. If the value is unset, the user will be
prompted (in an interactive session) to create a value for this
variable (using the value of NeticaLicenseKey
if it
exists) to create one.NeticaSession
object. Do not share licensed
session objects with people who are not authorized to use that
license key.NeticaSession
object. NeticaBN
objects (as well as case stream and
rng objects) have back pointers to the
session object (the
field $Session
). NeticaNode
objects
have back pointers to the network objects
(field $Net
). This should be mostly transparent to users.The 0.4 series of releases includes the following improvements:
The 0.3 series of releases includes a number of different improvements.
gctorture(TRUE)
, which should mean that is it is
much more robust to memory errors. This is still a beta version,
caution is still advisable.Known issues with this release.
Approximately 4/5 of the API functionality is mapped. Things that are still not mapped:
There are three layers to the complete RNetica environment, each with their own licensing terms.
Updated! Once you have obtained a license key from Norsys, the license is used by executing the following lines of code:
option("NeticaLicenseKey") <- string from NorsysThe function
NeticaSession()
will check for this value when creating new sessions.
Note that if DefaultNeticaSession
is used as the
identifier, most functions that need session arguments will accept this
value instead. See the help for StartNetica()
for
alternative ways of using the License key. (Backwards compatibility
is currently there.)
Note that the Netica license key is stored in plain text in
the options()
object. Do not share that object
(e.g., through sharing R dump files) with somebody who is not
authorized to use that license.
Without the license key, the Netica API operates in a limited mode. All of the functions in the test scripts will run, but the size of the networks is generally limited.
The current version (0.8-4) incorporates approximately 85% of the Netica C API Version 5.04 (5.10 for Windows). This is sufficient functionality to build, compile and carry out inferences with a Bayesian network. Some of the more advanced functionality, including support for databases, influence diagrams, and dynamic Bayesian networks is not yet developed. Some of the problem is related to missing functionality, which should be fixed with the Netica Version C API.
Although an extensive test script exists for RNetica (most of this is exposed on the manual pages), the testing away from these simple tests has been particularly light. In particular, I have not yet used valgrind to test for memory leaks. It is currently a beta release. Note that because it uses calls to C code, it is possible for RNetica to crash R. Plan your work accordingly.
The development has been with R version 3.0.1–3.6.3 under Ubuntu
16.04--18.04 with Netica API 5.04 (and 6.07) R CMD check RNetica
runs under Mac OS X and Windows 10 without errors. Almost all of the
testing has been with the 64 bit versions of R and Netica. There may
be some problems that crop up under 32 bit versions.
Version 0.2-7 was developed and tested under R 2.15.2. The windows binary for that version is a R 2.15 binary.
The following releases are archived here:
Note the source versions have been compiled and tested under Linux/Unix, Mac OS X and Windows. Note that for Windows and Mac OS X, compiling source packages requires the R development kit to be installed. See the appropriate R FAQ for your operating system. You should also be familiar with building R packages, see the Writing R Extensions manual.
Update:The next bit is now somewhat dated. If the configure
script doesn't have a --with-netica argument, pkg-config can't find
a netica
package and the NETICA_HOME
variable is not set, then it will attempt to download the Netica API
from Norsys. The older mechanisms should still work if you need
more control.
Compiling from sources requires that you have already downloaded and unpacked the Netica C API from Norsys. Under *nix (including Mac OS X) the location of the library can be passed to the configure command, e.g.:
R CMD INSTALL RNetica --configure-args='--with-netica=/Users/ralmond/software/Netica_API_504/'
Under Windows (or as an alternative to the --with-netica
switch), the environmental variable NETICA_HOME
can be
set to the location in which the Netica API was unpacked. I have only
tested with the API version 5.04, not with earlier (or later) versions.
Although I am now supplying Windows and Mac OS X binaries, which include the Netica API (currently version 5.04). As this is still an early test release, it will help you to have a local R guru to ask support questions, and help file bug reports if needed. NOTE: this is an unlicensed version of the API: you still need to purchase a license (although the unlicensed version will run the sample code in the man pages).
The latest development version is available as a github project: https://github.com/ralmond/RNetica/. The latest development version is available as a subversion repository at: https://pluto.coe.fsu.edu/svn/common/RNetica/trunk/. There is also a branch corresponding to the old object model at: https://pluto.coe.fsu.edu/svn/common/RNetica/branches/RNeticaS3.
If you have patches or other correspondence about RNetica you can contact me at russell.g.almond@gmail.com. If you are filing a bug report, please be sure to include the following information:
Netica and Norsys are registered trademarks of Norsys, LLC, used by permission.
Although Norsys has been generally supportive of the RNetica project, they do not offer formal support in any way. (In particular, the do not currently have anybody on staff who knows R.) All support requests should be sent to the package maintainers.
The software is offered AS IS, without any warranty of any kind. Support is provided on a volunteer basis, and may not be immediately forthcoming.