pax_global_header 0000666 0000000 0000000 00000000064 13476515412 0014522 g ustar 00root root 0000000 0000000 52 comment=131dd0781025d6cf596d6ac97c9a4f42dee289ce
aika-java-1.2.0/ 0000775 0000000 0000000 00000000000 13476515412 0013346 5 ustar 00root root 0000000 0000000 aika-java-1.2.0/.gitignore 0000664 0000000 0000000 00000000324 13476515412 0015335 0 ustar 00root root 0000000 0000000 # Maven build files
target
*.log
maven-eclipse.xml
build.properties
site-content
*~
# IntelliJ IDEA files
.idea
.iws
*.iml
*.ipr
# Eclipse files
.settings
.classpath
.project
.externalToolBuilders
.checkstyle
aika-java-1.2.0/LICENSE.txt 0000664 0000000 0000000 00000026134 13476515412 0015177 0 ustar 00root root 0000000 0000000
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2015-2017 Lukas Molzberger
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
aika-java-1.2.0/NOTICE.txt 0000664 0000000 0000000 00000000053 13476515412 0015066 0 ustar 00root root 0000000 0000000 AIKA
Copyright 2015-2017 Lukas Molzberger
aika-java-1.2.0/README.md 0000664 0000000 0000000 00000000707 13476515412 0014631 0 ustar 00root root 0000000 0000000 # aika
A good starting point to get familiar with this project are probably the following three test cases:
- SimplePatternMatchingTest (Demonstrates how a pattern like a word or a phrase can be matched)
- MutualExclusionTest (Demonstrates a negative feed back loop)
- NamedEntityRecognitionTest (A more complex example: recognize the name jackson cook)
- SuspensionTest (Demonstrates how neurons and logic nodes can be suspended to an external storage) aika-java-1.2.0/pom.xml 0000664 0000000 0000000 00000016153 13476515412 0014671 0 ustar 00root root 0000000 0000000 4.0.0org.aika-softwareaikajar1.2.0aikahttp://aika.networkAn artificial intelligence for knowledge acquisitionLukas MolzbergerLukas Molzbergercontact@aika-software.orgApache License, Version 2.0http://www.apache.org/licenses/LICENSE-2.0.txtrepohttps://github.com/aika-algorithm/aikascm:git:git://github.com/aika-algorithm/aika.gitscm:git:git@github.com:aika-algorithm/aika.gitaika-1.1.0ossrhhttps://oss.sonatype.org/content/repositories/snapshotsossrhhttps://oss.sonatype.org/service/local/staging/deploy/maven2/4.123.6.11.2.31.7.25org.apache.maven.pluginsmaven-compiler-plugin3.31111utf-8org.apache.maven.pluginsmaven-surefire-plugin2.18.1always-Xmx8000m**/*Test.javaorg.apache.maven.pluginsmaven-javadoc-pluginattach-javadocsjar-Xdoclint:noneorg.apache.maven.pluginsmaven-source-plugin2.2.1attach-sourcesjar-no-forkfalse../src/main/resources**/*false../src/test/resources**/*org.apache.commonscommons-math3${commons-math.version}org.slf4jslf4j-api${slf4j.version}ch.qos.logbacklogback-core${logback.version}testch.qos.logbacklogback-classic${logback.version}testjunitjunit${junit.version}testdeploy_artifactorg.apache.maven.pluginsmaven-gpg-plugin1.5sign-artifactsverifysignorg.sonatype.pluginsnexus-staging-maven-plugin1.6.7trueossrhhttps://oss.sonatype.org/true
aika-java-1.2.0/src/ 0000775 0000000 0000000 00000000000 13476515412 0014135 5 ustar 00root root 0000000 0000000 aika-java-1.2.0/src/main/ 0000775 0000000 0000000 00000000000 13476515412 0015061 5 ustar 00root root 0000000 0000000 aika-java-1.2.0/src/main/java/ 0000775 0000000 0000000 00000000000 13476515412 0016002 5 ustar 00root root 0000000 0000000 aika-java-1.2.0/src/main/java/network/ 0000775 0000000 0000000 00000000000 13476515412 0017473 5 ustar 00root root 0000000 0000000 aika-java-1.2.0/src/main/java/network/aika/ 0000775 0000000 0000000 00000000000 13476515412 0020400 5 ustar 00root root 0000000 0000000 aika-java-1.2.0/src/main/java/network/aika/AbstractNode.java 0000664 0000000 0000000 00000003357 13476515412 0023624 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package network.aika;
import network.aika.lattice.Node;
import network.aika.lattice.NodeActivation;
import network.aika.neuron.INeuron;
import network.aika.neuron.Neuron;
import java.io.DataInput;
import java.io.IOException;
/**
*
* @author Lukas Molzberger
*/
public abstract class AbstractNode
> implements Writable {
public volatile int lastUsedDocumentId = 0;
public volatile boolean modified;
protected P provider;
public P getProvider() {
return provider;
}
public void setModified() {
modified = true;
}
public void suspend() {}
public void reactivate() {}
public static
AbstractNode read(DataInput in, P p) throws IOException {
AbstractNode n;
if(in.readBoolean()) {
n = p.getModel().readNeuron(in, (Neuron) p);
} else {
n = Node.readNode(in, p);
}
return n;
}
}
aika-java-1.2.0/src/main/java/network/aika/ActivationFunction.java 0000664 0000000 0000000 00000001115 13476515412 0025050 0 ustar 00root root 0000000 0000000 package network.aika;
public enum ActivationFunction {
NULL_FUNCTION(x -> 0.0),
RECTIFIED_HYPERBOLIC_TANGENT(x -> Math.max(0.0, Math.tanh(x))),
RECTIFIED_LINEAR_UNIT(x -> Math.max(0.0, x)),
LIMITED_RECTIFIED_LINEAR_UNIT(x -> Math.max(0.0, Math.min(1.0, x)));
Function f;
ActivationFunction(Function f) {
this.f = f;
}
public double f(double x) {
return f.f(x);
}
interface Function {
double f(double x);
}
public static double sigmoid(double x) {
return 1.0 / (1.0 + Math.pow(Math.E, (-x)));
}
}
aika-java-1.2.0/src/main/java/network/aika/Document.java 0000664 0000000 0000000 00000045577 13476515412 0023043 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package network.aika;
import network.aika.lattice.Converter;
import network.aika.lattice.Node;
import network.aika.lattice.NodeActivation;
import network.aika.lattice.NodeQueue;
import network.aika.neuron.INeuron;
import network.aika.neuron.Synapse;
import network.aika.neuron.activation.Activation;
import network.aika.neuron.activation.Activation.Option;
import network.aika.neuron.activation.Activation.OscillatingActivationsException;
import network.aika.neuron.activation.Candidate;
import network.aika.neuron.activation.Position;
import network.aika.neuron.activation.SearchNode;
import network.aika.neuron.activation.SearchNode.TimeoutException;
import network.aika.neuron.activation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import java.util.stream.Collectors;
import static network.aika.neuron.activation.SearchNode.Decision.SELECTED;
import static network.aika.neuron.activation.SearchNode.Decision.UNKNOWN;
/**
* The {@code Document} class represents a single document which may be either used for processing a text or as
* training input. A document consists of the raw text, the interpretations and the activations.
*
*
When the document is not needed any more, the method {@code clearActivations} must be called, since Aika only
* supports a single document per thread and model.
*
* @author Lukas Molzberger
*/
public class Document implements Comparable {
private static final Logger log = LoggerFactory.getLogger(Document.class);
public static int CLEANUP_INTERVAL = 500;
public static int MAX_ROUND = 20;
public static int ROUND_LIMIT = -1;
/**
* Experimental code: not working yet!
*/
public static boolean INCREMENTAL_MODE = false;
private final int id;
private final StringBuilder content;
private long visitedCounter = 1;
private int activationIdCounter = 0;
private int nodeActivationIdCounter = 0;
public int searchNodeIdCounter = 0;
public int searchStepCounter = 0;
public int positionIdCounter = 0;
private Model model;
private int threadId;
private NodeQueue nodeQueue = new NodeQueue(this);
private ValueQueue valueQueue = new ValueQueue();
private UpperBoundQueue ubQueue = new UpperBoundQueue();
private Linker linker;
private TreeMap positions = new TreeMap<>();
private TreeSet activatedNodes = new TreeSet<>();
private TreeSet activatedNeurons = new TreeSet<>();
private TreeSet finallyActivatedNeurons = new TreeSet<>();
private TreeSet inputNeuronActivations = new TreeSet<>();
private TreeMap> modifiedWeights = new TreeMap<>();
private TreeMap activationsBySlotAndPosition = new TreeMap<>((ak1, ak2) -> {
int r = Integer.compare(ak1.slot, ak2.slot);
if (r != 0) return r;
r = Position.compare(ak1.pos, ak2.pos);
if (r != 0) return r;
r = ak1.neuron.compareTo(ak2.neuron);
if (r != 0) return r;
return Integer.compare(ak1.actId, ak2.actId);
});
private TreeMap activationsByPosition = new TreeMap<>((ak1, ak2) -> {
int r = Position.compare(ak1.pos, ak2.pos);
if (r != 0) return r;
r = ak1.neuron.compareTo(ak2.neuron);
if (r != 0) return r;
return Integer.compare(ak1.actId, ak2.actId);
});
private TreeMap activationsById = new TreeMap<>();
private int lastProcessedActivationId = -1;
private static class ActKey {
int slot;
Position pos;
INeuron neuron;
int actId;
public ActKey(int slot, Position pos, INeuron neuron, int actId) {
this.slot = slot;
this.pos = pos;
this.neuron = neuron;
this.actId = actId;
}
}
public TreeSet addedNodes = new TreeSet<>();
public ArrayList addedNodeActivations = new ArrayList<>();
public SearchNode selectedSearchNode;
public ArrayList candidates = new ArrayList<>();
public long createV;
public static Comparator ACTIVATIONS_OUTPUT_COMPARATOR = (act1, act2) -> {
int r = Position.compare(act1.lookupSlot(Activation.BEGIN), act2.lookupSlot(Activation.BEGIN));
if (r != 0) return r;
r = act1.getINeuron().compareTo(act2.getINeuron());
if (r != 0) return r;
return Integer.compare(act1.getId(), act2.getId());
};
public Document(Model model, String content) {
this(model, content, 0);
}
public Document(Model model, String content, int threadId) {
this(model, model.getNewDocumentId(), content, threadId);
}
public Document(Model model, int id, String content, int threadId) {
this.id = id;
this.content = new StringBuilder(content);
this.model = model;
this.threadId = threadId;
this.linker = initLinker();
model.acquireThread(threadId, this);
}
protected Linker initLinker() {
return new Linker(this);
}
public int getId() {
return id;
}
public Model getModel() {
return model;
}
public Linker getLinker() {
return linker;
}
public ValueQueue getValueQueue() {
return valueQueue;
}
public long getNewVisitedId() {
return visitedCounter++;
}
public int getNewActivationId() {
return activationIdCounter++;
}
public int getNewNodeActivationId() {
return nodeActivationIdCounter++;
}
public void addActivatedNode(Node n) {
activatedNodes.add(n);
}
public void addInputNeuronActivation(Activation act) {
inputNeuronActivations.add(act);
}
public void addFinallyActivatedNeuron(INeuron n) {
finallyActivatedNeurons.add(n);
}
public void addActivatedNeuron(INeuron n) {
activatedNeurons.add(n);
}
public int getThreadId() {
return threadId;
}
public void append(String txt) {
content.append(txt);
}
public char charAt(int i) {
return content.charAt(i);
}
public String getContent() {
return content.toString();
}
public int length() {
return content.length();
}
public String toString() {
return content.toString();
}
public UpperBoundQueue getUpperBoundQueue() {
return ubQueue;
}
public NodeQueue getNodeQueue() {
return nodeQueue;
}
public Position lookupFinalPosition(int pos) {
Position p = positions.get(pos);
if(p == null) {
p = new Position(this, pos);
positions.put(pos, p);
}
return p;
}
public String getText(Position begin, Position end) {
if(begin == null || end == null) {
return "";
}
return getText(begin.getFinalPosition(), end.getFinalPosition());
}
public String getText(Integer begin, Integer end) {
if(begin != null && end != null) {
return content.substring(
Math.max(0, Math.min(begin, length())),
Math.max(0, Math.min(end, length()))
);
} else {
return "";
}
}
public void addActivation(Activation act) {
for(Map.Entry me : act.getSlots().entrySet()) {
Position pos = me.getValue();
if (pos != null && pos.getFinalPosition() != null) {
ActKey dak = new ActKey(me.getKey(), pos, act.getINeuron(), act.getId());
activationsBySlotAndPosition.put(dak, act);
activationsByPosition.put(dak, act);
}
}
activationsById.put(act.getId(), act);
}
public Collection getActivations(boolean onlyFinal) {
if(!onlyFinal) {
return activationsById.values();
} else {
return activationsById
.values()
.stream()
.filter(act -> act.isFinalActivation())
.collect(Collectors.toList());
}
}
public Collection getActivationsByPosition(int fromSlot, Position fromPos, boolean fromInclusive, int toSlot, Position toPos, boolean toInclusive) {
return activationsBySlotAndPosition.subMap(
new Document.ActKey(fromSlot, fromPos, INeuron.MIN_NEURON, Integer.MIN_VALUE),
fromInclusive,
new Document.ActKey(toSlot, toPos, INeuron.MAX_NEURON, Integer.MAX_VALUE),
toInclusive
).values();
}
public Collection getActivationsByPosition(Position fromPos, boolean fromInclusive, Position toPos, boolean toInclusive) {
return activationsByPosition.subMap(
new Document.ActKey(-1, fromPos, INeuron.MIN_NEURON, Integer.MIN_VALUE),
fromInclusive,
new Document.ActKey(-1, toPos, INeuron.MAX_NEURON, Integer.MAX_VALUE),
toInclusive
).values();
}
public Activation getNextActivation(Activation currentAct) {
Map.Entry me = currentAct == null ?
activationsById.firstEntry() :
activationsById.higherEntry(currentAct.getId());
return me != null ? me.getValue() : null;
}
public int getNumberOfActivations() {
return activationsById.size();
}
@Override
public int compareTo(Document doc) {
return Integer.compare(id, doc.id);
}
public void propagate() {
boolean flag = true;
while(flag) {
nodeQueue.process();
flag = ubQueue.process();
}
}
public void generateCandidates() throws CyclicDependencyException {
TreeSet tmp = new TreeSet<>();
int i = 0;
if(!INCREMENTAL_MODE) {
candidates.clear();
}
for(Activation act: activationsById.subMap(INCREMENTAL_MODE ? lastProcessedActivationId : -1, false, Integer.MAX_VALUE, true).values()) {
if (act.getDecision() == UNKNOWN && act.getUpperBound() > 0.0) {
SearchNode.invalidateCachedDecision(act);
tmp.add(new Candidate(act, i++));
lastProcessedActivationId = Math.max(lastProcessedActivationId, act.getId());
}
}
long v = visitedCounter++;
for(Activation act: inputNeuronActivations) {
act.markedHasCandidate = v;
}
while (!tmp.isEmpty()) {
int oldSize = tmp.size();
for (Candidate c : tmp) {
if (c.checkDependenciesSatisfied(v)) {
tmp.remove(c);
c.setId(candidates.size());
candidates.add(c);
c.getActivation().markedHasCandidate = v;
break;
}
}
if(tmp.size() == oldSize) {
log.info(activationsToString());
throw new CyclicDependencyException();
}
}
}
/**
* The method process needs to be called after all the input activations have been added to the
* network. It performs the search for the best interpretation.
*/
public void process() throws TimeoutException, CyclicDependencyException, OscillatingActivationsException {
process(null);
}
public void process(Long timeoutInMilliSeconds) throws TimeoutException, CyclicDependencyException, OscillatingActivationsException {
linker.lateLinking();
inputNeuronActivations.forEach(act -> valueQueue.propagateActivationValue(0, act));
generateCandidates();
SearchNode rootNode = null;
if(selectedSearchNode == null || !INCREMENTAL_MODE) {
selectedSearchNode = new SearchNode(this, null, null, 0);
rootNode = selectedSearchNode;
}
SearchNode.search(this, selectedSearchNode, visitedCounter++, timeoutInMilliSeconds);
for(Activation act: activationsById.values()) {
if(act.isFinalActivation()) {
finallyActivatedNeurons.add(act.getINeuron());
}
}
if(SearchNode.COMPUTE_SOFT_MAX) {
SearchNode.computeCachedFactor(rootNode);
computeSoftMax();
}
}
private void computeSoftMax() {
for (Activation act : activationsById.values()) {
double offset = Double.MAX_VALUE;
for (Option option : act.getOptions()) {
offset = Math.min(offset, Math.log(option.cacheFactor) + option.weight);
}
double norm = 0.0;
for (Option option : act.getOptions()) {
norm += Math.exp(Math.log(option.cacheFactor) + option.weight - offset);
}
for (Option option : act.getOptions()) {
if (option.decision == SELECTED) {
option.p = Math.exp(Math.log(option.cacheFactor) + option.weight - offset) / norm;
}
}
}
}
public void dumpDebugCandidateStatistics() {
for (Candidate c : candidates) {
log.info(c.toString());
}
}
public void notifyWeightModified(Synapse synapse) {
Set is = modifiedWeights.get(synapse.getOutput().get());
if(is == null) {
is = new TreeSet<>(Synapse.INPUT_SYNAPSE_COMP);
modifiedWeights.put(synapse.getOutput().get(), is);
}
is.add(synapse);
}
public Map> getModifiedWeights() {
return modifiedWeights;
}
/**
* Updates the model after the training step.
* It applies the weight and bias delta values and reflects the changes in the logic node structure.
*/
public void commit() {
modifiedWeights.forEach((n, inputSyns) -> {
n.commit(inputSyns);
Converter.convert(threadId, this, n, inputSyns);
});
modifiedWeights.clear();
}
/**
* Removes the activations of this document from the model again.
*/
public void clearActivations() {
activatedNeurons.forEach(n -> n.clearActivations(this));
activatedNodes.forEach(n -> n.clearActivations(this));
activationsById.clear();
addedNodeActivations.clear();
activatedNeurons.clear();
activatedNodes.clear();
addedNodes.clear();
if(model.lastCleanup[threadId] + CLEANUP_INTERVAL < id) {
model.lastCleanup[threadId] = id;
List> tmp;
synchronized(model.activeProviders) {
tmp = new ArrayList<>(model.activeProviders.values());
}
tmp.forEach(np -> {
AbstractNode an = np.getIfNotSuspended();
if (an != null && an instanceof Node) {
Node n = (Node) an;
n.clearThreadState(threadId, id - CLEANUP_INTERVAL);
}
});
}
model.docs[threadId] = null;
}
public String generateOutputText() {
int oldLength = length();
TreeSet queue = new TreeSet<>(Comparator.comparingInt(p -> p.getId()));
for(Activation act: activationsById.values()) {
if(act.getINeuron().getOutputText() != null && act.lookupSlot(Activation.BEGIN).getFinalPosition() != null && act.lookupSlot(Activation.END).getFinalPosition() == null) {
queue.add(act.lookupSlot(Activation.BEGIN));
}
}
while(!queue.isEmpty()) {
Position pos = queue.pollFirst();
pos.getActivations(Activation.BEGIN)
.filter(act -> act.getINeuron().getOutputText() != null && act.isFinalActivation())
.forEach(act -> {
String outText = act.getINeuron().getOutputText();
Position nextPos = act.lookupSlot(Activation.END);
nextPos.setFinalPosition(pos.getFinalPosition() + outText.length());
content.replace(act.lookupSlot(Activation.BEGIN).getFinalPosition(), act.lookupSlot(Activation.END).getFinalPosition(), outText);
queue.add(nextPos);
});
}
return content.substring(oldLength, length());
}
public String activationsToString() {
Set acts = new TreeSet<>(ACTIVATIONS_OUTPUT_COMPARATOR);
acts.addAll(activationsById.values());
StringBuilder sb = new StringBuilder();
sb.append("Id -");
sb.append(" Decision -");
sb.append(" Range | Text Snippet");
sb.append(" | Identity -");
sb.append(" Neuron Label -");
sb.append(" Upper Bound -");
sb.append(" Value | Net | Weight -");
sb.append(" Input Value |");
sb.append(" Target Value");
sb.append("\n");
sb.append("\n");
for(Activation act: acts) {
if(act.getUpperBound() <= 0.0 && (act.getTargetValue() == null || act.getTargetValue() <= 0.0)) {
continue;
}
sb.append(act.toStringDetailed());
sb.append("\n");
}
if(selectedSearchNode != null) {
sb.append("\n Final SearchNode:" + selectedSearchNode.getId() + " WeightSum:" + selectedSearchNode.getAccumulatedWeight() + "\n");
}
return sb.toString();
}
public String dumpOscillatingActivations() {
StringBuilder sb = new StringBuilder();
activatedNeurons.stream()
.flatMap(n -> n.getActivations(this, false))
.filter(act -> act.isOscillating())
.forEach(act -> {
sb.append(act.getId() + " " + act.slotsToString() + " " + act.getDecision() + "\n");
sb.append(act.linksToString() + "\n");
sb.append("\n");
});
return sb.toString();
}
public static class CyclicDependencyException extends RuntimeException {
public CyclicDependencyException() {
super("Cycle detected in the activations that is not marked recurrent.");
}
}
}
aika-java-1.2.0/src/main/java/network/aika/Model.java 0000664 0000000 0000000 00000017774 13476515412 0022323 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package network.aika;
import network.aika.lattice.Node;
import network.aika.neuron.INeuron;
import network.aika.neuron.INeuron.Type;
import network.aika.neuron.Neuron;
import network.aika.Provider.SuspensionMode;
import network.aika.neuron.Synapse;
import network.aika.neuron.activation.Linker;
import network.aika.neuron.activation.SearchNode;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.lang.ref.WeakReference;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import static network.aika.neuron.INeuron.Type.INPUT;
/**
* The model consists of two layers. The first layer is the actual neural network consisting of neurons and synapses.
* The second layer is a pattern lattice containing a boolean logic representation of all the neurons. Whenever the
* synapse weights of a neuron are adjusted, then the underlying boolean logic representation of this neuron will be
* updated too.
*
*
The model supports parallel processing using a fixed number of threads.
*
* @author Lukas Molzberger
*/
public class Model {
public int numberOfThreads = 1;
public int[] lastCleanup;
public Document[] docs;
public SuspensionHook suspensionHook;
public SearchNode.SkipSelectStep skipSelectStep = (act) -> false;
public AtomicInteger docIdCounter = new AtomicInteger(0);
public AtomicInteger currentId = new AtomicInteger(0);
// Important: the id field needs to be referenced by the provider!
public WeakHashMap>> providers = new WeakHashMap<>();
public Map> activeProviders = new TreeMap<>();
public Map passiveActivationFunctions = new TreeMap<>();
public int defaultThreadId = 0;
public static AtomicLong visitedCounter = new AtomicLong(1);
/**
* Creates a model with a single thread.
*/
public Model() {
this(null, 1);
}
public Model(SuspensionHook sh, int numberOfThreads) {
assert numberOfThreads >= 1;
this.numberOfThreads = numberOfThreads;
lastCleanup = new int[numberOfThreads];
docs = new Document[numberOfThreads];
suspensionHook = sh;
}
public SuspensionHook getSuspensionHook() {
return suspensionHook;
}
public void setSuspensionHook(SuspensionHook suspensionHook) {
this.suspensionHook = suspensionHook;
}
public SearchNode.SkipSelectStep getSkipSelectStep() {
return skipSelectStep;
}
public void setSkipSelectStep(SearchNode.SkipSelectStep skipSelectStep) {
this.skipSelectStep = skipSelectStep;
}
public Neuron createNeuron(Type type) {
return createNeuron(null, type);
}
public Neuron createNeuron(String label, Type type) {
return createNeuron(label, type, type.getDefaultActivationFunction(), null);
}
public Neuron createNeuron(String label, Type type, ActivationFunction actF) {
return new INeuron(this, label, null, type, actF).getProvider();
}
public Neuron createNeuron(String label, Type type, String outputText) {
return new INeuron(this, label, outputText, type, type.getDefaultActivationFunction()).getProvider();
}
public Neuron createNeuron(String label, Type type, ActivationFunction actF, String outputText) {
return new INeuron(this, label, outputText, type, actF).getProvider();
}
public INeuron readNeuron(DataInput in, Neuron p) throws IOException {
INeuron n = new INeuron(p);
n.readFields(in, this);
return n;
}
public Synapse readSynapse(DataInput in) throws IOException {
Synapse s = new Synapse();
s.readFields(in, this);
return s;
}
public void writeSynapse(Synapse s, DataOutput out) throws IOException {
s.write(out);
}
public int getNewDocumentId() {
return docIdCounter.addAndGet(1);
}
public void acquireThread(int threadId, Document doc) {
if (docs[threadId] != null) {
throw new StaleDocumentException();
}
docs[threadId] = doc;
}
public Collection getActiveNeurons() {
List tmp = new ArrayList<>();
for(Provider p: activeProviders.values()) {
if(p instanceof Neuron) {
tmp.add((Neuron) p);
}
}
return tmp;
}
public
> P lookupNodeProvider(int id) {
synchronized (providers) {
WeakReference> wr = providers.get(id);
if(wr != null) {
P p = (P) wr.get();
if (p != null) {
return p;
}
}
return (P) new Provider(this, id);
}
}
public Neuron lookupNeuron(int id) {
synchronized (providers) {
WeakReference> wr = providers.get(id);
if(wr != null) {
Neuron n = (Neuron) wr.get();
if (n != null) {
return n;
}
}
return new Neuron(this, id);
}
}
public void register(Provider p) {
synchronized (activeProviders) {
activeProviders.put(p.id, p);
}
}
public void unregister(Provider p) {
synchronized (activeProviders) {
activeProviders.remove(p.id);
}
}
/**
* Suspend all neurons and logic nodes whose last used document id is lower/older than docId.
*
* @param docId
*/
public void suspendUnusedNodes(int docId, SuspensionMode sm) {
docId = Math.min(docId, getOldestDocIdInProcessing());
List tmp;
synchronized (activeProviders) {
tmp = new ArrayList<>(activeProviders.values());
}
for (Provider p: tmp) {
suspend(docId, p, sm);
}
}
public int getOldestDocIdInProcessing() {
int oldestDocId = Integer.MAX_VALUE;
for(Document doc: docs) {
if(doc != null) oldestDocId = Math.min(oldestDocId, doc.getId());
}
return oldestDocId;
}
/**
* Suspend all neurons and logic nodes in memory.
*
*/
public void suspendAll(SuspensionMode sm) {
suspendUnusedNodes(Integer.MAX_VALUE, sm);
}
private boolean suspend(int docId, Provider p, SuspensionMode sm) {
AbstractNode an = p.getIfNotSuspended();
if (an != null && an.lastUsedDocumentId < docId) {
p.suspend(sm);
return true;
}
return false;
}
public void removeProvider(Provider p) {
synchronized (activeProviders) {
activeProviders.remove(p.id);
}
synchronized (providers) {
providers.remove(p.id);
}
}
public static class StaleDocumentException extends RuntimeException {
public StaleDocumentException() {
super("Two documents are using the same thread. Call clearActivations() first, before processing the next document.");
}
}
}
aika-java-1.2.0/src/main/java/network/aika/PassiveInputFunction.java 0000664 0000000 0000000 00000000340 13476515412 0025400 0 ustar 00root root 0000000 0000000 package network.aika;
import network.aika.neuron.Synapse;
import network.aika.neuron.activation.Activation;
public interface PassiveInputFunction {
double getActivationValue(Synapse s, Activation outputActivation);
}
aika-java-1.2.0/src/main/java/network/aika/Provider.java 0000664 0000000 0000000 00000007102 13476515412 0023035 0 ustar 00root root 0000000 0000000 package network.aika;
import java.io.*;
import java.lang.ref.WeakReference;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
public class Provider implements Comparable> {
protected Model model;
protected Integer id;
private volatile T n;
public enum SuspensionMode {
SAVE,
DISCARD
}
public Provider(Model model, int id) {
this.model = model;
this.id = id;
if(model != null) {
synchronized (model.providers) {
model.providers.put(this.id, new WeakReference<>(this));
}
}
}
public Provider(Model model, T n) {
this.model = model;
this.n = n;
id = model.suspensionHook != null ? model.suspensionHook.getNewId() : model.currentId.addAndGet(1);
synchronized (model.providers) {
model.providers.put(id, new WeakReference<>(this));
if(n != null) {
model.register(this);
}
}
}
public Integer getId() {
return id;
}
public Model getModel() {
return model;
}
public boolean isSuspended() {
return n == null;
}
public T getIfNotSuspended() {
return n;
}
public synchronized T get() {
if (n == null) {
reactivate();
}
return n;
}
public synchronized T get(int lastUsedDocumentId) {
T n = get();
n.lastUsedDocumentId = Math.max(n.lastUsedDocumentId, lastUsedDocumentId);
return n;
}
/**
*
* @param doc The document is used to remember when this node has been used last.
* @return
*/
public T get(Document doc) {
return doc != null ? get(doc.getId()) : get();
}
public synchronized void suspend(SuspensionMode sm) {
if(n == null) return;
assert model.suspensionHook != null;
n.suspend();
model.unregister(this);
if(sm == SuspensionMode.SAVE) {
save();
}
n = null;
}
public void save() {
if (n.modified) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try (
GZIPOutputStream gzipos = new GZIPOutputStream(baos);
DataOutputStream dos = new DataOutputStream(gzipos);) {
n.write(dos);
} catch (IOException e) {
throw new RuntimeException(e);
}
model.suspensionHook.store(id, baos.toByteArray());
}
n.modified = false;
}
private void reactivate() {
assert model.suspensionHook != null;
byte[] data = model.suspensionHook.retrieve(id);
ByteArrayInputStream bais = new ByteArrayInputStream(data);
try (
GZIPInputStream gzipis = new GZIPInputStream(bais);
DataInputStream dis = new DataInputStream(gzipis);) {
n = (T) AbstractNode.read(dis, this);
} catch (IOException e) {
throw new RuntimeException(e);
}
n.reactivate();
model.register(this);
}
@Override
public boolean equals(Object o) {
return id == ((Provider) o).id;
}
@Override
public int hashCode() {
return id;
}
public String toString() {
return "p(" + id + ":" + (n != null ? n.toString() : "SUSPENDED") + ")";
}
public int compareTo(Provider n) {
if (id < n.id) return -1;
else if (id > n.id) return 1;
else return 0;
}
}
aika-java-1.2.0/src/main/java/network/aika/ReadWriteLock.java 0000664 0000000 0000000 00000005412 13476515412 0023744 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package network.aika;
/**
*
* @author Lukas Molzberger
*/
public class ReadWriteLock {
private int readers = 0;
private int writers = 0;
private int writeRequests = 0;
private long writerThreadId = -1;
private int waitForReadLock = 0;
private int waitForWriteLock = 0;
private Object writeLock = new Object();
public void acquireWriteLock() {
try {
synchronized (this) {
writeRequests++;
while (readers > 0) {
wait();
}
}
long tid = Thread.currentThread().getId();
synchronized (writeLock) {
if(writerThreadId != tid) {
waitForWriteLock++;
while (writers > 0) {
writeLock.wait();
}
waitForWriteLock--;
writerThreadId = tid;
}
writers++;
}
} catch(InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void acquireReadLock() {
try {
waitForReadLock++;
while (writeRequests > 0) {
wait();
}
waitForReadLock--;
readers++;
} catch(InterruptedException e) {
e.printStackTrace();
}
}
public void releaseWriteLock() {
synchronized (writeLock) {
writers--;
if(writers == 0) {
writerThreadId = -1;
if(waitForWriteLock > 0) {
writeLock.notify();
}
}
}
synchronized(this) {
writeRequests--;
if(writeRequests == 0 && waitForReadLock > 0) {
notifyAll();
}
}
}
public synchronized void releaseReadLock() {
readers--;
if(writeRequests > 0 && readers == 0) {
notifyAll();
}
}
} aika-java-1.2.0/src/main/java/network/aika/SuspensionHook.java 0000664 0000000 0000000 00000002474 13476515412 0024241 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package network.aika;
/**
*
* The suspension hook is used to suspend neurons and logic nodes to an external storage in order to reduce the memory footprint.
*
* !!! Important: When using the suspension hook, all references to a neuron or a logic node need to occur through a
* provider. Otherwise the reference might be outdated.
*
* @author Lukas Molzberger
*/
public interface SuspensionHook {
int getNewId();
void store(int id, byte[] data);
byte[] retrieve(int id);
Iterable getAllNodeIds();
}
aika-java-1.2.0/src/main/java/network/aika/Utils.java 0000664 0000000 0000000 00000002335 13476515412 0022346 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package network.aika;
/**
*
* @author Lukas Molzberger
*/
public class Utils {
public static double round(double x) {
return Math.round(x * 1000.0) / 1000.0;
}
public static String collapseText(String txt, int length) {
if (txt.length() <= 2 * length) {
return txt;
} else {
return txt.substring(0, length) + "..." + txt.substring(txt.length() - length);
}
}
}
aika-java-1.2.0/src/main/java/network/aika/Writable.java 0000664 0000000 0000000 00000003034 13476515412 0023014 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package network.aika;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
public interface Writable {
/**
* Serialize the fields of this object to out.
*
* @param out DataOuput to serialize this object into.
* @throws IOException
*/
void write(DataOutput out) throws IOException;
/**
* Deserialize the fields of this object from in.
*
*
For efficiency, implementations should attempt to re-use storage in the
* existing object where possible.
*
* @param in DataInput to deseriablize this object from.
* @throws IOException
*/
void readFields(DataInput in, Model m) throws IOException;
} aika-java-1.2.0/src/main/java/network/aika/lattice/ 0000775 0000000 0000000 00000000000 13476515412 0022025 5 ustar 00root root 0000000 0000000 aika-java-1.2.0/src/main/java/network/aika/lattice/AndNode.java 0000664 0000000 0000000 00000050637 13476515412 0024213 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package network.aika.lattice;
import network.aika.Document;
import network.aika.Model;
import network.aika.Provider;
import network.aika.Writable;
import network.aika.neuron.relation.Relation;
import network.aika.neuron.activation.Activation;
import network.aika.lattice.InputNode.InputActivation;
import network.aika.lattice.AndNode.AndActivation;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.util.*;
/**
* The {@code InputNode} and the {@code AndNode} classes together form a pattern lattice, containing all
* possible substructures of any given conjunction. For example if we have the conjunction ABCD where A, B, C, D are
* the inputs, then the pattern lattice will contain the nodes ABCD, ABC, ABD, ACD, BCD, AB, AC, AD, BC, BD, CD,
* A, B, C, D. The pattern lattice is organized in layers, where each layer only contains conjunctions/patterns of the
* same size. These layers are connected through refinements. For example the and-node
* ABD on layer 3 is connected to the and-node ABCD on layer 4 via the refinement C.
*
* @author Lukas Molzberger
*/
class AndNode extends Node {
List parents;
public AndNode() {
parents = new ArrayList<>();
}
public AndNode(Model m, int level, List parents) {
super(m, level);
this.parents = parents;
}
private void init() {
for(Entry e: parents) {
e.rv.child = provider;
Node pn = e.rv.parent.get();
pn.addAndChild(e.ref, e.rv);
pn.setModified();
}
}
@Override
protected void propagate(AndActivation act) {
if (andChildren != null) {
for (Link fl : act.inputs) {
if(fl == null) continue;
NodeActivation pAct = fl.input;
for (Link sl : pAct.outputsToAndNode.values()) {
NodeActivation secondAct = sl.output;
if (act != secondAct) {
applyIntern(act, fl.refAct, fl.ref, fl.rv, secondAct, sl.refAct, sl.ref, sl.rv);
}
}
}
}
propagateToOrNode(act);
}
@Override
public void cleanup() {
if(!isRemoved && !isRequired()) {
remove();
for(Entry e: parents) {
e.rv.parent.get().cleanup();
}
}
}
@Override
void processActivation(AndActivation act) {
if(act.isComplete()) {
super.processActivation(act);
}
}
private void applyIntern(AndActivation act, InputActivation refAct, Refinement ref, RefValue rv, NodeActivation secondAct, InputActivation secondRefAct, Refinement secondRef, RefValue secondRv) {
Document doc = act.getDocument();
lock.acquireReadLock();
for(Map.Entry me: andChildren.subMap(
new Refinement(RelationsMap.MIN, secondRef.input),
new Refinement(RelationsMap.MAX, secondRef.input)).entrySet()) {
Refinement nRef = me.getKey();
RefValue nRv = me.getValue();
if(nRef.contains(secondRef, rv)) {
AndNode nlNode = nRv.child.get(doc);
AndActivation nlAct = lookupAndActivation(act, nRef);
if(nlAct == null) {
nlAct = new AndActivation(doc, nlNode);
nlAct.link(nRef, nRv, secondRefAct, act);
}
nlAct.getNode().addActivation(nlAct);
for(Entry secondNE: nlNode.parents) {
if(secondNE.rv.parent.get(doc) == secondAct.getNode() && secondNE.ref.contains(ref, secondRv)) {
nlAct.link(secondNE.ref, secondNE.rv, refAct, secondAct);
break;
}
}
}
}
lock.releaseReadLock();
}
private AndActivation lookupAndActivation(NodeActivation input, Refinement ref) {
for (Link l : input.outputsToAndNode.values()) {
if(l.ref.compareTo(ref) == 0) {
return l.output;
}
}
return null;
}
RefValue expand(int threadId, Document doc, Refinement firstRef) {
if(!firstRef.isConvertible()) return null;
RefValue firstRV = getAndChild(firstRef);
if(firstRV != null) {
return firstRV;
}
int firstRefOffset = level;
Integer[] firstOffsets = new Integer[level];
for(int i = 0; i < firstOffsets.length; i++) {
firstOffsets[i] = i;
}
List nextLevelParents = new ArrayList<>();
for(Entry firstParent: parents) {
Node parentNode = firstParent.rv.parent.get(doc);
Refinement secondParentRef = new Refinement(getParentRelations(firstRef, firstParent), firstRef.input);
RefValue secondParentRV = parentNode.expand(threadId, doc, secondParentRef);
if(secondParentRV == null) {
continue;
}
Refinement secondRef = new Refinement(getRelations(firstRef, firstParent, secondParentRV), firstParent.ref.input);
RefValue secondRV = new RefValue(getOffsets(firstRefOffset, firstParent, secondParentRV), firstOffsets[firstParent.rv.refOffset], secondParentRV.child);
nextLevelParents.add(new Entry(secondRef, secondRV));
}
firstRV = new RefValue(firstOffsets, firstRefOffset, provider);
nextLevelParents.add(new Entry(firstRef, firstRV));
return createAndNode(provider.getModel(), doc, nextLevelParents, level + 1) ? firstRV : null;
}
private RelationsMap getParentRelations(Refinement firstRef, Entry firstParent) {
Relation[] secondParentRelations = new Relation[firstRef.relations.length() - 1];
for(int i = 0; i < firstRef.relations.length(); i++) {
Integer j = firstParent.rv.reverseOffsets[i];
if(j != null) {
secondParentRelations[j] = firstRef.relations.get(i);
}
}
return new RelationsMap(secondParentRelations);
}
private static RelationsMap getRelations(Refinement firstRef, Entry firstParent, RefValue secondParentRV) {
Relation[] secondRelations = new Relation[firstParent.ref.relations.length() + 1];
for(int i = 0; i < firstParent.ref.relations.length(); i++) {
int j = secondParentRV.offsets[i];
secondRelations[j] = firstParent.ref.relations.get(i);
}
Relation rel = firstRef.relations.get(firstParent.rv.refOffset);
if(rel != null) {
secondRelations[secondParentRV.refOffset] = rel.invert();
}
return new RelationsMap(secondRelations);
}
private static Integer[] getOffsets(int firstRefOffset, Entry firstParent, RefValue secondParentRV) {
Integer[] secondOffsets = new Integer[secondParentRV.offsets.length + 1];
for(int i = 0; i < firstParent.rv.reverseOffsets.length; i++) {
Integer j = firstParent.rv.reverseOffsets[i];
if(j != null) {
secondOffsets[secondParentRV.offsets[j]] = i;
}
}
secondOffsets[secondParentRV.refOffset] = firstRefOffset;
return secondOffsets;
}
static boolean createAndNode(Model m, Document doc, List parents, int level) {
if (parents != null) {
// Locking needs to take place in a predefined order.
TreeSet> parentsForLocking = new TreeSet();
for(Entry e: parents) {
parentsForLocking.add(e.rv.parent);
}
for (Provider pn : parentsForLocking) {
pn.get().lock.acquireWriteLock();
}
try {
AndNode nln = new AndNode(m, level, parents);
nln.init();
nln.postCreate(doc);
} finally {
for (Provider pn : parentsForLocking) {
pn.get().lock.releaseWriteLock();
}
}
}
return true;
}
@Override
public void changeNumberOfNeuronRefs(int threadId, long v, int d) {
super.changeNumberOfNeuronRefs(threadId, v, d);
parents.forEach(e -> e.rv.parent.get().changeNumberOfNeuronRefs(threadId, v, d));
}
@Override
public void reprocessInputs(Document doc) {
for(Entry e: parents) {
Node> pn = e.rv.parent.get();
for(NodeActivation act : pn.getActivations(doc)) {
act.repropagateV = markedCreated;
act.getNode().propagate(act);
}
}
}
@Override
public void remove() {
super.remove();
for(Entry e: parents) {
Node pn = e.rv.parent.get();
pn.lock.acquireWriteLock();
pn.removeAndChild(e.ref);
pn.setModified();
pn.lock.releaseWriteLock();
}
}
public String logicToString() {
StringBuilder sb = new StringBuilder();
sb.append("AND(" + level + ")[");
boolean first = true;
for(Entry e: parents) {
if(!first) {
sb.append(",");
}
first = false;
sb.append(e.ref);
}
sb.append("]");
return sb.toString();
}
@Override
public void write(DataOutput out) throws IOException {
out.writeBoolean(false);
out.writeChar('A');
super.write(out);
out.writeInt(parents.size());
for(Entry e: parents) {
e.ref.write(out);
e.rv.write(out);
}
}
@Override
public void readFields(DataInput in, Model m) throws IOException {
super.readFields(in, m);
int s = in.readInt();
for(int i = 0; i < s; i++) {
Refinement ref = Refinement.read(in, m);
RefValue rv = RefValue.read(in, m);
parents.add(new Entry(ref, rv));
}
}
/**
*
*/
public static class Refinement implements Comparable, Writable {
public RelationsMap relations;
public Provider input;
private Refinement() {}
public Refinement(RelationsMap relations, Provider input) {
this.relations = relations;
this.input = input;
}
public boolean isConvertible() {
for(Relation rel: relations.relations) {
if(rel != null && rel.isConvertible()) return true;
}
return false;
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("(");
sb.append(relations);
sb.append(input.get().logicToString());
sb.append(")");
return sb.toString();
}
public void write(DataOutput out) throws IOException {
relations.write(out);
out.writeInt(input.getId());
}
public void readFields(DataInput in, Model m) throws IOException {
relations = RelationsMap.read(in, m);
input = m.lookupNodeProvider(in.readInt());
}
public static Refinement read(DataInput in, Model m) throws IOException {
Refinement k = new Refinement();
k.readFields(in, m);
return k;
}
@Override
public int compareTo(Refinement ref) {
int r = input.compareTo(ref.input);
if(r != 0) return r;
return relations.compareTo(ref.relations);
}
public boolean contains(Refinement ref, RefValue rv) {
for(int i = 0; i < ref.relations.length(); i++) {
Relation ra = ref.relations.get(i);
Relation rb = relations.get(rv.offsets[i]);
if((ra == null && rb != null) || (ra != null && rb == null)) return false;
if(ra != null && rb != null && ra.compareTo(rb) != 0) {
return false;
}
}
return true;
}
}
public static class RelationsMap implements Comparable, Writable {
public static final RelationsMap MIN = new RelationsMap();
public static final RelationsMap MAX = new RelationsMap();
public Relation[] relations;
public RelationsMap() {}
public RelationsMap(Relation[] relations) {
this.relations = relations;
}
public void write(DataOutput out) throws IOException {
out.writeInt(relations.length);
for(int i = 0; i < relations.length; i++) {
Relation rel = relations[i];
out.writeBoolean(rel != null);
if(rel != null) {
rel.write(out);
}
}
}
public void readFields(DataInput in, Model m) throws IOException {
int l = in.readInt();
relations = new Relation[l];
for(int i = 0; i < l; i++) {
if(in.readBoolean()) {
relations[i] = Relation.read(in, m);
}
}
}
public static RelationsMap read(DataInput in, Model m) throws IOException {
RelationsMap k = new RelationsMap();
k.readFields(in, m);
return k;
}
public String toString() {
StringBuilder sb = new StringBuilder();
for(int i = 0; i < relations.length; i++) {
Relation rel = relations[i];
if(rel != null) {
sb.append(i + ":" + rel + ", ");
}
}
return sb.toString();
}
@Override
public int compareTo(RelationsMap rm) {
if (this == MIN) return -1;
if (rm == MIN) return 1;
if (this == MAX) return 1;
if (rm == MAX) return -1;
int r = Integer.compare(relations.length, rm.relations.length);
if(r != 0) return r;
for(int i = 0; i < relations.length; i++) {
Relation ra = relations[i];
Relation rb = rm.relations[i];
if(ra == null && rb == null) continue;
if(ra == null && rb != null) return -1;
if(ra != null && rb == null) return 1;
r = ra.compareTo(rb);
if(r != 0) return r;
}
return 0;
}
public int length() {
return relations.length;
}
public Relation get(int i) {
return relations[i];
}
public int size() {
if(relations.length == 0) return 0;
int count = 0;
for(int i = 0; i < relations.length; i++) {
if(relations[i] != null) count++;
}
return count;
}
public boolean isExact() {
for(Relation rel: relations) {
if(!rel.isExact()) {
return false;
}
}
return true;
}
}
public static class RefValue implements Writable {
public Integer[] offsets; // input offsets -> output offsets
public Integer[] reverseOffsets; // output offsets -> input offsets
public int refOffset;
public Provider parent;
public Provider child;
private RefValue() {}
public RefValue(Integer[] offsets, int refOffset, Provider parent) {
this.offsets = offsets;
reverseOffsets = new Integer[offsets.length + 1];
for(int i = 0; i < offsets.length; i++) {
reverseOffsets[offsets[i]] = i;
}
this.refOffset = refOffset;
this.parent = parent;
}
@Override
public void write(DataOutput out) throws IOException {
out.writeInt(offsets.length);
for(int i = 0; i < offsets.length; i++) {
Integer ofs = offsets[i];
out.writeBoolean(ofs != null);
out.writeInt(ofs);
}
out.writeInt(refOffset);
out.writeInt(parent.getId());
out.writeInt(child.getId());
}
public static RefValue read(DataInput in, Model m) throws IOException {
RefValue rv = new RefValue();
rv.readFields(in, m);
return rv;
}
@Override
public void readFields(DataInput in, Model m) throws IOException {
int l = in.readInt();
offsets = new Integer[l];
reverseOffsets = new Integer[l + 1];
for(int i = 0; i < l; i++) {
if(in.readBoolean()) {
Integer ofs = in.readInt();
offsets[i] = ofs;
reverseOffsets[ofs] = i;
}
}
refOffset = in.readInt();
parent = m.lookupNodeProvider(in.readInt());
child = m.lookupNodeProvider(in.readInt());
}
}
public static class Entry {
public Refinement ref;
public RefValue rv;
public Entry(Refinement ref, RefValue rv) {
this.ref = ref;
this.rv = rv;
}
}
public static class AndActivation extends NodeActivation {
public Link[] inputs;
public AndActivation(Document doc, AndNode node) {
super(doc, node);
inputs = new Link[node.level];
}
public void link(Refinement ref, RefValue rv, InputActivation refAct, NodeActivation input) {
Link l = new Link(ref, rv, refAct, input, this);
inputs[rv.refOffset] = l;
input.outputsToAndNode.put(id, l);
}
public Activation getInputActivation(int i) {
Link l = inputs[i];
if(l != null) {
return l.refAct.input;
} else {
for(int j = 0; j < inputs.length; j++) {
if (j != i) {
l = inputs[j];
if(l != null) {
return l.input.getInputActivation(l.rv.reverseOffsets[i]);
}
}
}
return null;
}
}
public boolean isComplete() {
int numberOfLinks = 0;
for (Link l : inputs) {
if (l != null) numberOfLinks++;
}
return getNode().parents.size() == numberOfLinks;
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("A-ACT(");
boolean first = true;
for(int i = 0; i < inputs.length; i++) {
Activation iAct = getInputActivation(i);
if(iAct != null) {
if(!first) {
sb.append(",");
}
sb.append(i + ":" + iAct.getLabel() + " " + iAct.slotsToString() + " (" + iAct.getId() + ")");
first = false;
}
}
sb.append(")");
return sb.toString();
}
}
public static class Link {
public Refinement ref;
public RefValue rv;
public NodeActivation input;
public InputActivation refAct;
public AndActivation output;
public Link(Refinement ref, RefValue rv, InputActivation refAct, NodeActivation input, AndActivation output) {
this.ref = ref;
this.rv = rv;
this.refAct = refAct;
this.input = input;
this.output = output;
}
}
}
aika-java-1.2.0/src/main/java/network/aika/lattice/Converter.java 0000664 0000000 0000000 00000023070 13476515412 0024641 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package network.aika.lattice;
import network.aika.Document;
import network.aika.neuron.INeuron;
import network.aika.neuron.INeuron.SynapseSummary;
import network.aika.neuron.Synapse;
import network.aika.neuron.relation.Relation;
import java.util.*;
import static network.aika.neuron.Synapse.State.CURRENT;
/**
* Converts the synapse weights of a neuron into a boolean logic representation of this neuron.
*
* @author Lukas Molzberger
*/
public class Converter {
public static int MAX_AND_NODE_SIZE = 10;
public static Comparator SYNAPSE_COMP = (s1, s2) -> {
int r = Boolean.compare(
s2.linksAnyOutput() || s2.isIdentity(),
s1.linksAnyOutput() || s1.isIdentity()
);
if (r != 0) return r;
r = Double.compare(s2.getWeight(), s1.getWeight());
if (r != 0) return r;
return Integer.compare(s1.getId(), s2.getId());
};
private int threadId;
private INeuron neuron;
private Document doc;
private OrNode outputNode;
private Collection modifiedSynapses;
public static boolean convert(int threadId, Document doc, INeuron neuron, Collection modifiedSynapses) {
return new Converter(threadId, doc, neuron, modifiedSynapses).convert();
}
private Converter(int threadId, Document doc, INeuron neuron, Collection modifiedSynapses) {
this.doc = doc;
this.neuron = neuron;
this.threadId = threadId;
this.modifiedSynapses = modifiedSynapses;
}
private boolean convert() {
outputNode = neuron.getInputNode().get();
SynapseSummary ss = neuron.getSynapseSummary();
if(neuron.getTotalBias(CURRENT) + ss.getPosDirSum() + ss.getPosRecSum() <= 0.0) {
outputNode.removeParents(threadId);
return false;
}
switch(neuron.getType()) {
case EXCITATORY:
if(hasOnlyWeakSynapses()) {
convertWeakSynapses();
} else {
convertConjunction();
}
break;
case INHIBITORY:
convertDisjunction();
break;
case INPUT:
break;
}
return true;
}
private void convertConjunction() {
SynapseSummary ss = neuron.getSynapseSummary();
outputNode.removeParents(threadId);
List candidates = prepareCandidates();
double sum = 0.0;
NodeContext nodeContext = null;
double remainingSum = ss.getPosDirSum();
int i = 0;
boolean optionalInputMode = false;
for (Synapse s : candidates) {
double v = s.getMaxInputValue();
boolean belowThreshold = sum + v + remainingSum + ss.getPosRecSum() + ss.getPosPassiveSum() + neuron.getTotalBias(CURRENT) <= 0.0;
if (belowThreshold) {
return;
}
if(sum + remainingSum - v + ss.getPosRecSum() + ss.getPosPassiveSum() + neuron.getTotalBias(CURRENT) > 0.0) {
optionalInputMode = true;
}
if (!optionalInputMode) {
NodeContext nlNodeContext = expandNode(nodeContext, s);
if (nlNodeContext == null) {
return;
}
nodeContext = nlNodeContext;
remainingSum -= v;
sum += v;
i++;
} else {
NodeContext nlNodeContext = expandNode(nodeContext, s);
if (nlNodeContext != null) {
outputNode.addInput(nlNodeContext.getSynapseIds(), threadId, nlNodeContext.node, true);
remainingSum -= v;
}
}
final boolean sumOfSynapseWeightsAboveThreshold = sum + ss.getPosRecSum() + ss.getPosPassiveSum() + neuron.getTotalBias(CURRENT) > 0.0;
final boolean maxAndNodesReached = i >= MAX_AND_NODE_SIZE;
if (sumOfSynapseWeightsAboveThreshold || maxAndNodesReached) {
break;
}
}
if(nodeContext != null && !optionalInputMode) {
outputNode.addInput(nodeContext.getSynapseIds(), threadId, nodeContext.node, true);
}
}
private boolean hasOnlyWeakSynapses() {
for(Synapse s: neuron.getInputSynapses()) {
if(!s.isWeak(CURRENT)) {
return false;
}
}
return true;
}
private void convertWeakSynapses() {
TreeSet synapsesSortedByWeight = new TreeSet<>((s1, s2) -> {
int r = Double.compare(s2.getWeight(), s1.getWeight());
if(r != 0) return r;
return SYNAPSE_COMP.compare(s1, s2);
});
synapsesSortedByWeight.addAll(neuron.getInputSynapses());
double sum = 0.0;
for (Synapse s : synapsesSortedByWeight) {
if (!s.isRecurrent()) {
sum += s.getWeight();
NodeContext nlNodeContext = expandNode(null, s);
outputNode.addInput(nlNodeContext.getSynapseIds(), threadId, nlNodeContext.node, true);
if(sum > neuron.getBias()) {
// break; // siehe: AIKA-1
}
}
}
}
private void convertDisjunction() {
for (Synapse s : modifiedSynapses) {
if (!s.isRecurrent() && !s.isWeak(CURRENT)) {
NodeContext nlNodeContext = expandNode(null, s);
outputNode.addInput(nlNodeContext.getSynapseIds(), threadId, nlNodeContext.node, false);
}
}
}
private List prepareCandidates() {
Synapse syn = getStrongestSynapse(neuron.getInputSynapses());
if(syn == null) {
return Collections.EMPTY_LIST;
}
TreeSet alreadyCollected = new TreeSet<>();
ArrayList selectedCandidates = new ArrayList<>();
TreeMap relatedSyns = new TreeMap<>();
while(syn != null && selectedCandidates.size() < MAX_AND_NODE_SIZE) {
relatedSyns.remove(syn.getId());
selectedCandidates.add(syn);
alreadyCollected.add(syn.getId());
for(Map.Entry me: syn.getRelations().entrySet()) {
Integer relId = me.getKey();
Relation rel = me.getValue();
if(rel.isConvertible() && !alreadyCollected.contains(relId)) {
Synapse rs = syn.getOutput().getSynapseById(relId);
if(rs != null) {
relatedSyns.put(relId, rs);
}
}
}
syn = getStrongestSynapse(relatedSyns.values());
}
return selectedCandidates;
}
private Synapse getStrongestSynapse(Collection synapses) {
Synapse maxSyn = null;
for(Synapse s: synapses) {
if(!s.isNegative(CURRENT) && !s.isRecurrent() && !s.isInactive() && !s.getInput().get().isPassiveInputNeuron()) {
if(maxSyn == null || SYNAPSE_COMP.compare(maxSyn, s) > 0) {
maxSyn = s;
}
}
}
return maxSyn;
}
private NodeContext expandNode(NodeContext nc, Synapse s) {
if (nc == null) {
NodeContext nln = new NodeContext();
nln.node = s.getInput().get().getOutputNode().get();
nln.offsets = new Synapse[] {s};
return nln;
} else {
Relation[] relations = new Relation[nc.offsets.length];
for(int i = 0; i < nc.offsets.length; i++) {
Synapse linkedSynapse = nc.offsets[i];
relations[i] = s.getRelationById(linkedSynapse.getId());
}
NodeContext nln = new NodeContext();
nln.offsets = new Synapse[nc.offsets.length + 1];
AndNode.Refinement ref = new AndNode.Refinement(new AndNode.RelationsMap(relations), s.getInput().get().getOutputNode());
AndNode.RefValue rv = nc.node.expand(threadId, doc, ref);
if(rv == null) {
return null;
}
nln.node = rv.child.get(doc);
for (int i = 0; i < nc.offsets.length; i++) {
nln.offsets[rv.offsets[i]] = nc.offsets[i];
}
for (int i = 0; i < nln.offsets.length; i++) {
if (nln.offsets[i] == null) {
nln.offsets[i] = s;
}
}
return nln;
}
}
private class NodeContext {
Node node;
Synapse[] offsets;
int[] getSynapseIds() {
int[] result = new int[offsets.length];
for(int i = 0; i < result.length; i++) {
result[i] = offsets[i].getId();
}
return result;
}
}
}
aika-java-1.2.0/src/main/java/network/aika/lattice/InputNode.java 0000664 0000000 0000000 00000021336 13476515412 0024602 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package network.aika.lattice;
import network.aika.Document;
import network.aika.Model;
import network.aika.Provider;
import network.aika.neuron.Neuron;
import network.aika.neuron.activation.Position;
import network.aika.neuron.relation.Relation;
import network.aika.neuron.activation.Activation;
import network.aika.lattice.AndNode.AndActivation;
import network.aika.lattice.InputNode.InputActivation;
import network.aika.lattice.AndNode.Refinement;
import network.aika.lattice.AndNode.RefValue;
import network.aika.lattice.AndNode.RelationsMap;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.util.*;
/**
* The {@code InputNode} class is the input layer for the boolean logic. The input-node has two sources of
* activations. First, it might be underlying logic node of an {@code InputNeuron} in which case the input
* activations come from the outside. The second option is that the activation come from the output of another neuron.
*
* @author Lukas Molzberger
*/
public class InputNode extends Node {
public static int CHILD_NODE_THRESHOLD = 10;
private Neuron inputNeuron;
private TreeMap nonExactAndChildren;
public InputNode() {
}
public InputNode(Model m) {
super(m, 1);
}
public void setInputNeuron(Neuron n) {
inputNeuron = n;
}
public void addActivation(Activation inputAct) {
// if(inputAct.repropagateV != null && inputAct.repropagateV != markedCreated) return;
InputActivation act = new InputActivation(inputAct, this);
addActivation(act);
}
public void reprocessInputs(Document doc) {
inputNeuron.get(doc).getActivations(doc, false).forEach(act -> {
// act.repropagateV = markedCreated;
if(act.getUpperBound() > 0.0) {
act.getINeuron().propagate(act);
}
});
}
void addAndChild(AndNode.Refinement ref, AndNode.RefValue child) {
super.addAndChild(ref, child);
if(!ref.relations.isExact()) {
if (nonExactAndChildren == null) {
nonExactAndChildren = new TreeMap<>();
}
AndNode.RefValue n = nonExactAndChildren.put(ref, child);
assert n == null;
}
}
void removeAndChild(AndNode.Refinement ref) {
super.removeAndChild(ref);
if(!ref.relations.isExact()) {
if (nonExactAndChildren != null) {
nonExactAndChildren.remove(ref);
if (nonExactAndChildren.isEmpty()) {
nonExactAndChildren = null;
}
}
}
}
public RefValue expand(int threadId, Document doc, Refinement ref) {
if(!ref.isConvertible()) return null;
Relation rel = ref.relations.get(0);
if(rel == null) {
return null;
}
RefValue rv = getAndChild(ref);
if(rv != null) {
return rv;
}
List nlParents = new ArrayList<>();
Refinement mirrorRef = new Refinement(new AndNode.RelationsMap(new Relation[]{rel.invert()}), provider);
nlParents.add(new AndNode.Entry(mirrorRef, new RefValue(new Integer[] {1}, 0, ref.input)));
rv = new RefValue(new Integer[] {0}, 1, provider);
nlParents.add(new AndNode.Entry(ref, rv));
return AndNode.createAndNode(provider.getModel(), doc, nlParents, level + 1) ? rv : null;
}
/**
* @param act
*/
@Override
protected void propagate(InputActivation act) {
try {
lock.acquireReadLock();
if (andChildren != null) {
TreeMap children;
if(andChildren.size() > CHILD_NODE_THRESHOLD) {
children = nonExactAndChildren;
propagateWithExactRelations(act);
} else {
children = andChildren;
}
if(children != null) {
children.forEach((ref, rv) -> {
InputNode in = ref.input.getIfNotSuspended();
if (in != null) {
in.addNextLevelActivations(ref, rv.child.get(act.getDocument()), act);
}
});
}
}
} finally {
lock.releaseReadLock();
}
propagateToOrNode(act);
}
private void propagateWithExactRelations(InputActivation act) {
Activation iAct = act.input;
Document doc = act.getDocument();
for (Map.Entry me : iAct.getSlots().entrySet()) {
for (Activation linkedAct : act.getDocument().getActivationsByPosition(me.getValue(), true, me.getValue(), true)) {
Provider in = linkedAct.getINeuron().getOutputNode();
for (Map.Entry mea : andChildren.subMap(
new Refinement(RelationsMap.MIN, in),
new Refinement(RelationsMap.MAX, in)).entrySet()) {
in.get(doc).addNextLevelActivations(mea.getKey(), mea.getValue().child.get(doc), act);
}
}
}
}
private void addNextLevelActivations(Refinement ref, AndNode nln, InputActivation act) {
Document doc = act.getDocument();
if(inputNeuron.get().isEmpty(doc)) return;
Activation iAct = act.input;
if(act.repropagateV != null && act.repropagateV != nln.markedCreated) return;
ref.relations.get(0).getActivations(inputNeuron.get(doc), iAct)
.filter(secondIAct -> secondIAct.getOutputNodeActivation() != null)
.map(secondIAct -> secondIAct.getOutputNodeActivation())
.filter(secondAct -> secondAct != null && secondAct.registered)
.forEach(secondAct -> {
// if (!Conflicts.isConflicting(iAct, secondIAct)) {
AndActivation oAct = new AndActivation(doc, nln);
for (AndNode.Entry e : nln.parents) {
boolean match = e.ref.compareTo(ref) == 0;
oAct.link(e.ref, e.rv, match ? secondAct : act, match ? act : secondAct);
}
nln.addActivation(oAct);
// }
}
);
}
@Override
public void cleanup() {
}
public String logicToString() {
StringBuilder sb = new StringBuilder();
sb.append("I");
sb.append("[");
if (inputNeuron != null) {
sb.append(inputNeuron.getId());
if (inputNeuron.getLabel() != null) {
sb.append(",");
sb.append(inputNeuron.getLabel());
}
}
sb.append("]");
return sb.toString();
}
@Override
public void write(DataOutput out) throws IOException {
out.writeBoolean(false);
out.writeChar('I');
super.write(out);
out.writeBoolean(inputNeuron != null);
if (inputNeuron != null) {
out.writeInt(inputNeuron.getId());
}
}
@Override
public void readFields(DataInput in, Model m) throws IOException {
super.readFields(in, m);
if (in.readBoolean()) {
inputNeuron = m.lookupNeuron(in.readInt());
}
}
public static class InputActivation extends NodeActivation {
public Activation input;
public InputActivation(Activation iAct, InputNode node) {
super(iAct.getDocument(), node);
input = iAct;
iAct.setOutputNodeActivation(this);
}
public Activation getInputActivation(int i) {
assert i == 0;
return input;
}
public String toString() {
return "I-ACT(" + input.getLabel() + " " + input.slotsToString() + ")";
}
}
}
aika-java-1.2.0/src/main/java/network/aika/lattice/Node.java 0000664 0000000 0000000 00000031242 13476515412 0023557 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package network.aika.lattice;
import network.aika.*;
import network.aika.Document;
import java.io.*;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* The {@code Node} class is the abstract class for all the boolean logic nodes underneath the neural network layer.
* These nodes form a boolean representation for all the neurons of the neural network. Whenever changes occur to the
* synapse weights in the neural layer, then the structure of the boolean representation needs to be adjusted. Several
* neurons, however, might share common substructures in this boolean representation. The {@code InputNode} and
* the {@code AndNode} classes together form a pattern lattice, containing all possible substructures of any
* given conjunction. For example if we have the conjunction ABCD where A, B, C, D are the inputs then the
* pattern lattice will contain the nodes ABCD, ABC, ABD, ACD, BCD, AB, AC, AD, BC, BD, CD, A, B, C, D. The class
* {@code OrNode} is a disjunction of either input-nodes or and-nodes. The or-node is connected with one of
* the neurons.
*