• AutoNetica generates websites from Bayes nets. Example site
• Generates presentation quality graphics which can be incorporated into other documents.
• Version 5.0 and later can do TAN learning of link structure from data.
• Compiles belief (Bayesian) networks into a junction tree of cliques for fast probabilistic reasoning.
• Extensive built-in and online help.
• Utility-free sensitivity analysis.
• Can generate highly customizable reports on many aspects of the Bayes net, nodes, states, CPTs, cases, findings, beliefs, sensitivity results, other inference results, etc.
• Can test the performance of a network using a file of cases.
• Netica will print out a confusion matrix, error rate, logarithmic and quadratic (Brier) scoring rule results, calibration table and surprise indexes for each node desired.
• Can find optimal decisions for sequential decision problems (i.e., later decisions are dependent on the results of earlier ones).
• Can solve influence diagrams efficiently by using clique trees.
• Can learn probabilistic relations from data, even with missing data.
• Provides easy graphical editing of belief networks and influence diagrams, including:
  • cut / paste / duplicate nodes without losing their probabilistic relation
  • many ways of displaying the nodes (bar graphs, meters, etc.)
  • links with bends to keep complex diagrams orderly
  • allows comments, keeps track of author, when changed, etc. for each node
  • unlimited levels of undo / redo
• Allows the entry of probabilistic relations by equation, with an extensive built-in library of probabilistic functions and other mathematical functions.
• Has facilities for the easy discretization of continuous variables.
• Can reverse individual links and "sum out" nodes of influence diagrams or belief nets, for model exploration.
• Supports disconnected links, which makes possible libraries of probabilistic relationships (See Figure 1).
• It is possible to represent networks with nodes whose values change over time (a persistence is defined for such nodes), and to have links with time delays (which allows cycles). The software can automatically convert these networks into expanded regular networks covering a limited period of time (See Figure 2).
• Accepts likelihood findings (i.e., virtual evidence), and findings of the form that some variable is not in some state.
• Can display nodes and inference results in a number of forms, including bar graphs of beliefs and a true/false meter (See Figure 3).
• Easy to customize the display to be suitable for an end-user.
• Supports documentation and tracking of every node and network (with comments, titles, author, when last changed, etc.)
• Has no built in limits on the size or complexity of networks, so they are limited only by available memory.
• Can work hand-in-hand with the Netica API product (for example, sharing the same files).

Figure 1	Figure 2

The Netica APIs(Application Programmer Interfaces) are a family of powerful Bayesian Network toolkits. They allow you to build your own Bayesian belief networks and influence diagrams, do probabilistic inference, learn nets from data, modify nets, and save and restore nets.

The API Family
Netica APIs(Application Programmer Interfaces) Includes Java, C#, Visual Basic, C++ and C versions.

系統需求

Versions of Netica API are available for most popular platforms, including Microsoft Windows 95/98/Me/NT4/2000/XP/Vista, Linux, Sun Sparc, Mac (68000, PPC: OS 6 to 9 & OS-X), Silicon Graphics and DOS.

General Features
Each Netica API has the following features:

• World-renowned Engine. All Netica products are founded on the same core software engine. This engine has seen fourteen years of service, enhancement, and field testing, and is now a trusted component of many of the world's leading-edge Bayesian Network applications.
• Interoperability. All of the Netica APIs use the same Bayesian network file formats as Netica Application, so they can share networks and case files amongst each other.
• Broad Platform Support. Versions of Netica API are available for Microsoft Windows (95/NT4 to XP), Linux, Sun Sparc, Macintosh (OS 6 to OS-X), Silicon Graphics and DOS. Each of these has an identical interface, so you can move your code between these platforms without changing anything to do with the Netica API. Versions of Netica exist for Java, C, and Visual Basic, and many languages (e.g., C++, Delphi, Pascal, Lisp, Fortran, Cobol) can use the C version. Versions are similar in design to allow for easier porting.
• Encryption. Applications using proprietary Bayes nets can be deployed while keeping the underlying Bayes nets securely hidden.
• Strict Quality Assurance. Before releasing any new version of the Netica API, every function is put through rigorous Quality Assurance testing to make sure it operates as designed. Hundreds of real networks and thousands of random networks are generated and solved in multiple ways to check the inference results. BoundsChecker and Purify are used to make sure there are no memory leaks or other memory faults. This level of Quality Assurance combined with a careful initial design and eight years of extensive customer usage has resulted in a rock-solid product.
• Prompt Support. If you ever find a bug in a Netica API and describe it to us in a detailed enough form that we can reproduce it, we will make it our top priority to fix the bug, and send you a corrected version or a work-around, and aim to do so within 2 weeks.
• Forward Compatibility. Netica APIs are designed to be easily extended in the future without changing what already exists, so you will not have to change your software.
• Growth and Continued Support. Many new features are currently under development, and will be incorporated into future versions. The API will continue to be extended for years to come.

Software Features
If you are an experienced software developer, you will appreciate the following features:

• Speed. The Netica API inference engine has been optimized for speed. It uses the fastest exact algorithms; for example, it compiles Bayes nets and influence diagrams into a junction tree of cliques for fast probabilistic reasoning.
• Documentation. Each API comes with excellent documentation including example programs and detailed descriptions of each function. They come with a colorized PDF manual suitable for printing, as well as a hypertext point-and-click on-line HTML manual that makes searching for function definitions very fast and easy. The C-API version of the PDF manual includes introductory chapters on Bayes nets, decision networks, learning, and more.
• Surprise-free, Deterministic Behavior. Programs that use the API completely control it. No API function will ever take any action until called. The API will not do any I/O unless requested to, and all functions take a predictable amount of time before returning. Also, a limit may be set on the maximum amount of memory that Netica will use.
• Name-space Freedom. Care has been taken to make the Netica API library functions good project citizens. The Netica APIs can be used with other libraries and won't interfere with them.
• Minimal Dependencies. The C-API does not require any other library than the Standard C library. The Java-API does not require any other set of java packages than those that come with a standard Java 2 environment.
• Meets Developer Expectations. Each API has an orientation that is suited to developers in that particular programming language. Naming conventions are respected. Exception handling is employed, if available. Appropriate I/O streaming packages are employed. If variable prototypes are supported, they are used in a way that is natural.
• 100% Compatibility with Netica Application. Many developers find it invaluable to use the Netica Application as a graphical user interface (Windows version only) to the same Bayes nets Netica API uses.
• Thread Safe. Can safely be used in a multithreading environment.
• Database Connectivity. Allows direct connection to most database software.
• User Data Support. Every node and network can store by name arbitrary data fields defined by you. These are saved to file when the object in question is being saved.
• Flexible Argument Validation. The programmer can control how carefully API functions check their arguments when they are called, including a "development mode" to extensively check everything passed to an API function.
• Error Handling. The APIs have a simple but powerful method for handling usage errors, which can generate very detailed error messages if desired. The API makes use of exception-handling in those languages that support it.

Bayes Net Features
If you are knowledgeable about Bayesian Networks, you will especially appreciate the following features:

• Learning. Probabilistic relations can be learned from case data, even while the net is being used for probabilistic inference. Learning from data can be combined with entry by hand and representation by equations. It can handle missing data and latent variables or hidden nodes. Learning algorithms include: counting, sequential updating, fractional updating, EM (expectation maximization), gradient descent and TAN.
• Advanced Decision Nets. Can solve influence diagrams which have multiple utility and decision nodes to find optimal decisions and conditional plans, using a junction tree algorithm for speed. Handles multi-stage decision problems, where later decisions depend on the outcomes of earlier ones, and on observations not initially known. No-forgetting links need not be explicitly specified.
• Equation Support. Large and complex probability tables do not need to be entered by hand, if they can be expressed by an equation. The equation language follows a Java/C++ syntax and contains an extensive library of built-in functions, including all the standard math functions and common probability distributions, as well as some functions and distributions suited to Bayes nets, such as Noisy-or, Noisy-max, Noisy-sum, etc.
• Sophisticated Findings Support. Netica API not only supports the traditional state and real-valued findings, but also virtual evidence, likelihood findings, gaussian distribution findings, interval findings, and negative findings (those claiming that some variable is not in some state).
• Case Support. Can save individual cases (i.e., sets of findings) to file, and manipulate files of cases. Handles incomplete cases. Can associate a multiplicity and identification number with each case. Allows direct connection to most databases, for case management.
• Simulation Support. Can do sampling (discrete simulation) to generate random cases with a probability distribution matching the Bayes net. Can use a junction tree algorithm for speed, or direct sampling for nets too large to generate CPTs or a junction tree.
• Sensitivity. Netica can efficiently measure the degree to which findings at any node can influence the beliefs at another node, given the findings currently entered. The measures can be in the form of mutual information (entropy reduction), or the expected reduction of real variance.
• Dynamic Construction. Can build networks "on the fly" in memory to support working with dynamic Bayes nets (DBNs).
• Junction Tree Algorithm. Can compile Bayes nets and influence diagrams into a junction tree of cliques for fast probabilistic inference. An elimination order can be set or Netica can determine one automatically, and Netica can report on the resulting junction tree.
• Link Reversal. It can reverse individual links or "sum out" (absorb) nodes while maintaining the same joint probability distribution, properly accounting for any findings in the removed nodes or other nodes.
• Disconnected Link Support. Links may be individually named and disconnected from parent or child nodes, thus making possible libraries of network fragments which you may then copy and connect to other networks or node configurations.