From cdd9cd6977e498cc3d7f908f5141fa1344b60ed3 Mon Sep 17 00:00:00 2001
From: luigiba <baldarigigi@gmail.com>
Date: Tue, 30 Jul 2019 15:23:11 +0200
Subject: [PATCH] First Commit

---
 .idea/misc.xml                                |   6 +
 .idea/modules.xml                             |   8 +
 .idea/vcs.xml                                 |   6 +
 .idea/workspace.xml                           | 490 ++++++++++++++
 Config.py                                     | 632 ++++++++++++++++++
 LICENSE                                       |  21 +
 Model.py                                      |  99 +++
 OpenKE_new_Spark.iml                          |   9 +
 README.md                                     |   2 +
 TransD.py                                     |  98 +++
 TransE.py                                     |  58 ++
 TransH.py                                     |  82 +++
 TransR.py                                     |  87 +++
 __pycache__/Config.cpython-36.pyc             | Bin 0 -> 18420 bytes
 __pycache__/Model.cpython-36.pyc              | Bin 0 -> 3932 bytes
 __pycache__/TransD.cpython-36.pyc             | Bin 0 -> 3675 bytes
 __pycache__/TransE.cpython-36.pyc             | Bin 0 -> 2230 bytes
 __pycache__/TransH.cpython-36.pyc             | Bin 0 -> 2815 bytes
 __pycache__/TransR.cpython-36.pyc             | Bin 0 -> 3115 bytes
 .../distribute_training.cpython-36.pyc        | Bin 0 -> 7691 bytes
 base/Base.cpp                                 | 177 +++++
 base/Corrupt.h                                | 149 +++++
 base/Random.h                                 |  41 ++
 base/Reader.h                                 | 365 ++++++++++
 base/Setting.h                                | 127 ++++
 base/Test.h                                   | 411 ++++++++++++
 base/Triple.h                                 |  36 +
 base/Valid.h                                  |  78 +++
 distribute_training.py                        | 292 ++++++++
 main_spark.py                                 | 370 ++++++++++
 make.sh                                       |   1 +
 release/Base.so                               | Bin 0 -> 74416 bytes
 run.sh                                        | 249 +++++++
 33 files changed, 3894 insertions(+)
 create mode 100644 .idea/misc.xml
 create mode 100644 .idea/modules.xml
 create mode 100644 .idea/vcs.xml
 create mode 100644 .idea/workspace.xml
 create mode 100644 Config.py
 create mode 100644 LICENSE
 create mode 100644 Model.py
 create mode 100644 OpenKE_new_Spark.iml
 create mode 100644 README.md
 create mode 100644 TransD.py
 create mode 100644 TransE.py
 create mode 100644 TransH.py
 create mode 100644 TransR.py
 create mode 100644 __pycache__/Config.cpython-36.pyc
 create mode 100644 __pycache__/Model.cpython-36.pyc
 create mode 100644 __pycache__/TransD.cpython-36.pyc
 create mode 100644 __pycache__/TransE.cpython-36.pyc
 create mode 100644 __pycache__/TransH.cpython-36.pyc
 create mode 100644 __pycache__/TransR.cpython-36.pyc
 create mode 100644 __pycache__/distribute_training.cpython-36.pyc
 create mode 100644 base/Base.cpp
 create mode 100644 base/Corrupt.h
 create mode 100644 base/Random.h
 create mode 100644 base/Reader.h
 create mode 100644 base/Setting.h
 create mode 100644 base/Test.h
 create mode 100644 base/Triple.h
 create mode 100644 base/Valid.h
 create mode 100644 distribute_training.py
 create mode 100644 main_spark.py
 create mode 100644 make.sh
 create mode 100755 release/Base.so
 create mode 100644 run.sh

diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 0000000..4c1170f
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_12" default="false" project-jdk-name="Python 3.6" project-jdk-type="Python SDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
new file mode 100644
index 0000000..80f322d
--- /dev/null
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/OpenKE_new_Spark.iml" filepath="$PROJECT_DIR$/OpenKE_new_Spark.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000..94a25f7
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
new file mode 100644
index 0000000..ea9b0b8
--- /dev/null
+++ b/.idea/workspace.xml
@@ -0,0 +1,490 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ChangeListManager">
+    <list default="true" id="fd9b69df-948f-43d7-abff-74da8c63edc1" name="Default Changelist" comment="" />
+    <ignored path="$PROJECT_DIR$/out/" />
+    <option name="EXCLUDED_CONVERTED_TO_IGNORED" value="true" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="DefaultGradleProjectSettings">
+    <option name="isMigrated" value="true" />
+  </component>
+  <component name="FileEditorManager">
+    <leaf SIDE_TABS_SIZE_LIMIT_KEY="300" />
+  </component>
+  <component name="FileTemplateManagerImpl">
+    <option name="RECENT_TEMPLATES">
+      <list>
+        <option value="Python Script" />
+      </list>
+    </option>
+  </component>
+  <component name="FindInProjectRecents">
+    <findStrings>
+      <find>head_lef</find>
+      <find>head_rig</find>
+      <find>tail_rig</find>
+      <find>bern</find>
+      <find>get_similar_entites</find>
+      <find>summary_op</find>
+      <find>_global_step_tensor</find>
+      <find>config</find>
+      <find>argv</find>
+      <find>TODO</find>
+      <find>def set_mode</find>
+      <find>return</find>
+      <find>batch_h_addr</find>
+      <find>res_pos</find>
+      <find>corrupt_head</find>
+      <find>early_stop_stopping_setp</find>
+      <find>rand_max</find>
+      <find>valid_</find>
+      <find>corrupt</find>
+      <find>tail_lef</find>
+      <find>tail_type</find>
+      <find>trainList</find>
+      <find>judgeHeadBatch</find>
+      <find>tripleTotal</find>
+      <find>rand</find>
+      <find>corrupt(</find>
+      <find>setConstrainFlag</find>
+      <find>getTripleTotal</find>
+      <find>std</find>
+      <find>workThreads</find>
+    </findStrings>
+  </component>
+  <component name="IdeDocumentHistory">
+    <option name="CHANGED_PATHS">
+      <list>
+        <option value="$PROJECT_DIR$/base/Reader.h" />
+        <option value="$PROJECT_DIR$/base/Setting.h" />
+        <option value="$PROJECT_DIR$/base/Base.cpp" />
+        <option value="$PROJECT_DIR$/test.py" />
+        <option value="$PROJECT_DIR$/base/Random.h" />
+        <option value="$PROJECT_DIR$/base/Corrupt.h" />
+        <option value="$PROJECT_DIR$/distribute_training.py" />
+        <option value="$PROJECT_DIR$/Config.py" />
+        <option value="$PROJECT_DIR$/base/Test.h" />
+        <option value="$PROJECT_DIR$/example_test_transe.py" />
+        <option value="$PROJECT_DIR$/main_spark.py" />
+      </list>
+    </option>
+  </component>
+  <component name="ProjectFrameBounds" extendedState="6">
+    <option name="x" value="293" />
+    <option name="y" value="53" />
+    <option name="width" value="1400" />
+    <option name="height" value="1000" />
+  </component>
+  <component name="ProjectView">
+    <navigator proportions="" version="1">
+      <foldersAlwaysOnTop value="true" />
+    </navigator>
+    <panes>
+      <pane id="PackagesPane" />
+      <pane id="Scope" />
+      <pane id="ProjectPane">
+        <subPane>
+          <expand>
+            <path>
+              <item name="OpenKE_new_Spark" type="b2602c69:ProjectViewProjectNode" />
+              <item name="OpenKE_new_Spark" type="462c0819:PsiDirectoryNode" />
+            </path>
+            <path>
+              <item name="OpenKE_new_Spark" type="b2602c69:ProjectViewProjectNode" />
+              <item name="OpenKE_new_Spark" type="462c0819:PsiDirectoryNode" />
+              <item name="base" type="462c0819:PsiDirectoryNode" />
+            </path>
+          </expand>
+          <select />
+        </subPane>
+      </pane>
+    </panes>
+  </component>
+  <component name="PropertiesComponent">
+    <property name="SHARE_PROJECT_CONFIGURATION_FILES" value="true" />
+    <property name="project.structure.last.edited" value="Project" />
+    <property name="project.structure.proportion" value="0.15" />
+    <property name="project.structure.side.proportion" value="0.2" />
+    <property name="settings.editor.selected.configurable" value="preferences.editor" />
+  </component>
+  <component name="RunDashboard">
+    <option name="ruleStates">
+      <list>
+        <RuleState>
+          <option name="name" value="ConfigurationTypeDashboardGroupingRule" />
+        </RuleState>
+        <RuleState>
+          <option name="name" value="StatusDashboardGroupingRule" />
+        </RuleState>
+      </list>
+    </option>
+  </component>
+  <component name="RunManager" selected="Python.example_test_transe">
+    <configuration name="example_test_transe" type="PythonConfigurationType" factoryName="Python" temporary="true">
+      <module name="OpenKE_new_Spark" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <envs>
+        <env name="PYTHONUNBUFFERED" value="1" />
+      </envs>
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="IS_MODULE_SDK" value="true" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <option name="SCRIPT_NAME" value="$PROJECT_DIR$/example_test_transe.py" />
+      <option name="PARAMETERS" value="" />
+      <option name="SHOW_COMMAND_LINE" value="false" />
+      <option name="EMULATE_TERMINAL" value="false" />
+      <option name="MODULE_MODE" value="false" />
+      <option name="REDIRECT_INPUT" value="false" />
+      <option name="INPUT_FILE" value="" />
+      <method v="2" />
+    </configuration>
+    <configuration name="test" type="PythonConfigurationType" factoryName="Python" temporary="true">
+      <module name="OpenKE_new_Spark" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <envs>
+        <env name="PYTHONUNBUFFERED" value="1" />
+      </envs>
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="IS_MODULE_SDK" value="true" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <option name="SCRIPT_NAME" value="$PROJECT_DIR$/test.py" />
+      <option name="PARAMETERS" value="" />
+      <option name="SHOW_COMMAND_LINE" value="false" />
+      <option name="EMULATE_TERMINAL" value="false" />
+      <option name="MODULE_MODE" value="false" />
+      <option name="REDIRECT_INPUT" value="false" />
+      <option name="INPUT_FILE" value="" />
+      <method v="2" />
+    </configuration>
+    <recent_temporary>
+      <list>
+        <item itemvalue="Python.example_test_transe" />
+        <item itemvalue="Python.test" />
+      </list>
+    </recent_temporary>
+  </component>
+  <component name="SvnConfiguration">
+    <configuration />
+  </component>
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="fd9b69df-948f-43d7-abff-74da8c63edc1" name="Default Changelist" comment="" />
+      <created>1563207549465</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1563207549465</updated>
+    </task>
+    <servers />
+  </component>
+  <component name="TodoView">
+    <todo-panel id="selected-file">
+      <is-autoscroll-to-source value="true" />
+    </todo-panel>
+    <todo-panel id="all">
+      <are-packages-shown value="true" />
+      <is-autoscroll-to-source value="true" />
+    </todo-panel>
+  </component>
+  <component name="ToolWindowManager">
+    <frame x="67" y="25" width="1853" height="1055" extended-state="6" />
+    <layout>
+      <window_info active="true" content_ui="combo" id="Project" order="0" visible="true" weight="0.10182623" />
+      <window_info id="Structure" order="1" side_tool="true" weight="0.25" />
+      <window_info id="Image Layers" order="2" />
+      <window_info id="Designer" order="3" />
+      <window_info id="UI Designer" order="4" />
+      <window_info id="Capture Tool" order="5" />
+      <window_info id="Favorites" order="6" side_tool="true" />
+      <window_info anchor="bottom" id="Message" order="0" />
+      <window_info anchor="bottom" id="Find" order="1" />
+      <window_info anchor="bottom" id="Run" order="2" weight="0.34913793" />
+      <window_info anchor="bottom" id="Debug" order="3" weight="0.4" />
+      <window_info anchor="bottom" id="Cvs" order="4" weight="0.25" />
+      <window_info anchor="bottom" id="Inspection" order="5" weight="0.4" />
+      <window_info anchor="bottom" id="TODO" order="6" weight="0.3297414" />
+      <window_info anchor="bottom" id="Terminal" order="7" />
+      <window_info anchor="bottom" id="Event Log" order="8" side_tool="true" />
+      <window_info anchor="bottom" id="Version Control" order="9" />
+      <window_info anchor="bottom" id="Messages" order="10" />
+      <window_info anchor="right" id="Commander" internal_type="SLIDING" order="0" type="SLIDING" weight="0.4" />
+      <window_info anchor="right" id="Ant Build" order="1" weight="0.25" />
+      <window_info anchor="right" content_ui="combo" id="Hierarchy" order="2" weight="0.25" />
+      <window_info anchor="right" id="Palette" order="3" />
+      <window_info anchor="right" id="Maven" order="4" />
+      <window_info anchor="right" id="Theme Preview" order="5" />
+      <window_info anchor="right" id="Capture Analysis" order="6" />
+      <window_info anchor="right" id="Palette&#9;" order="7" />
+    </layout>
+  </component>
+  <component name="UnknownFeatures">
+    <option featureType="com.intellij.fileTypeFactory" implementationName="*.cpp" />
+    <option featureType="com.intellij.fileTypeFactory" implementationName="*.h" />
+  </component>
+  <component name="editorHistoryManager">
+    <entry file="file://$PROJECT_DIR$/make.sh">
+      <provider selected="true" editor-type-id="text-editor" />
+    </entry>
+    <entry file="file://$PROJECT_DIR$/example_train_transe.py">
+      <provider selected="true" editor-type-id="text-editor">
+        <state>
+          <folding>
+            <element signature="e#0#13#0" expanded="true" />
+          </folding>
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$USER_HOME$/.local/lib/python3.6/site-packages/tensorflow/python/summary/writer/writer.py" />
+    <entry file="file://$USER_HOME$/.local/lib/python3.6/site-packages/tensorflow/python/training/training_util.py" />
+    <entry file="file://$USER_HOME$/.local/lib/python3.6/site-packages/tensorflow/python/training/session_run_hook.py" />
+    <entry file="file://$USER_HOME$/.local/lib/python3.6/site-packages/tensorflow/python/training/monitored_session.py" />
+    <entry file="file://$USER_HOME$/.local/lib/python3.6/site-packages/google/protobuf/reflection.py">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="253">
+          <caret line="55" selection-start-line="55" selection-end-line="55" />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$USER_HOME$/.local/lib/python3.6/site-packages/tensorflow/core/protobuf/config_pb2.py" />
+    <entry file="file://$PROJECT_DIR$/run.sh">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="-1170" />
+      </provider>
+    </entry>
+    <entry file="file://$USER_HOME$/.local/lib/python3.6/site-packages/tensorflowonspark/TFNode.py">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="572">
+          <caret line="62" column="4" selection-start-line="62" selection-start-column="4" selection-end-line="62" selection-end-column="4" />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/config/Config.py">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="495">
+          <caret line="39" column="44" lean-forward="true" selection-start-line="39" selection-start-column="44" selection-end-line="39" selection-end-column="44" />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/Model.py">
+      <provider selected="true" editor-type-id="text-editor" />
+    </entry>
+    <entry file="file://$PROJECT_DIR$/base/Triple.h">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="225">
+          <caret line="15" column="5" selection-start-line="15" selection-start-column="5" selection-end-line="15" selection-end-column="5" />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/old.py">
+      <provider selected="true" editor-type-id="text-editor">
+        <state>
+          <folding>
+            <element signature="e#113#3600#0" />
+          </folding>
+        </state>
+      </provider>
+    </entry>
+    <entry file="file:///usr/local/lib/python3.6/dist-packages/tensorflow/python/training/monitored_session.py">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="-4935">
+          <caret line="349" column="4" selection-start-line="349" selection-start-column="4" selection-end-line="349" selection-end-column="4" />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/base/Setting.h">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="1770">
+          <caret line="118" selection-start-line="118" selection-end-line="120" selection-end-column="30" />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/base/Valid.h">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="285">
+          <caret line="19" selection-start-line="19" selection-end-line="19" />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/TransE.py">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="195">
+          <caret line="15" selection-start-line="15" selection-end-line="15" />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file:///usr/local/lib/python3.6/dist-packages/tensorflow/python/training/saver.py">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="9735">
+          <caret line="685" column="6" selection-start-line="685" selection-start-column="6" selection-end-line="685" selection-end-column="6" />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/test.py">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="300">
+          <caret line="20" column="28" selection-start-line="20" selection-start-column="28" selection-end-line="20" selection-end-column="28" />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/base/Random.h">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="285">
+          <caret line="19" selection-start-line="19" selection-end-line="19" />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/base/Reader.h">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="868">
+          <caret line="245" column="42" selection-start-line="245" selection-start-column="4" selection-end-line="245" selection-end-column="42" />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/base/Corrupt.h">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="193">
+          <caret line="108" column="35" selection-start-line="108" selection-start-column="35" selection-end-line="108" selection-end-column="35" />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/base/Base.cpp">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="868">
+          <caret line="105" column="9" selection-start-line="105" selection-start-column="9" selection-end-line="105" selection-end-column="9" />
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/distribute_training.py">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="630">
+          <caret line="124" selection-start-line="124" selection-end-line="124" />
+          <folding>
+            <element signature="e#0#25#0" expanded="true" />
+            <element signature="e#520#827#0" />
+            <element signature="e#1992#3073#0" />
+            <element signature="e#3101#3873#0" />
+          </folding>
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/example_test_transe.py">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="405">
+          <caret line="30" column="20" selection-start-line="30" selection-start-column="20" selection-end-line="30" selection-end-column="20" />
+          <folding>
+            <element signature="e#0#25#0" expanded="true" />
+          </folding>
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/main_spark.py">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="-1763">
+          <caret line="142" selection-start-line="142" selection-end-line="142" />
+          <folding>
+            <element signature="e#0#15#0" expanded="true" />
+          </folding>
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/Config.py">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="-1905">
+          <caret line="185" column="41" selection-start-line="185" selection-start-column="41" selection-end-line="185" selection-end-column="41" />
+          <folding>
+            <element signature="e#14#32#0" expanded="true" />
+          </folding>
+        </state>
+      </provider>
+    </entry>
+    <entry file="file://$PROJECT_DIR$/base/Test.h">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="689">
+          <caret line="404" column="62" selection-start-line="404" selection-start-column="62" selection-end-line="404" selection-end-column="62" />
+        </state>
+      </provider>
+    </entry>
+  </component>
+  <component name="masterDetails">
+    <states>
+      <state key="ArtifactsStructureConfigurable.UI">
+        <settings>
+          <artifact-editor />
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+      <state key="FacetStructureConfigurable.UI">
+        <settings>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+      <state key="GlobalLibrariesConfigurable.UI">
+        <settings>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+      <state key="JdkListConfigurable.UI">
+        <settings>
+          <last-edited>Python 3.6</last-edited>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+      <state key="ModuleStructureConfigurable.UI">
+        <settings>
+          <last-edited>OpenKE_new_Spark</last-edited>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+      <state key="ProjectLibrariesConfigurable.UI">
+        <settings>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+    </states>
+  </component>
+</project>
\ No newline at end of file
diff --git a/Config.py b/Config.py
new file mode 100644
index 0000000..7601c38
--- /dev/null
+++ b/Config.py
@@ -0,0 +1,632 @@
+#coding:utf-8
+import numpy as np
+import tensorflow as tf
+import os
+import time
+import datetime
+import ctypes
+import json
+#EDIT
+import sys
+
+class Config(object):
+    '''
+    use ctypes to call C functions from python and set essential parameters.
+    '''
+    #EDIT
+    def __init__(self, cpp_lib_path=None, init_new_entities=False):
+        #EDIT
+        self.init_new_entities = init_new_entities
+
+        if init_new_entities == False:
+            # base_file = os.path.abspath(os.path.join(os.path.dirname(__file__), '../release/Base.so'))
+            #TODO: add main_spark parameter
+            if cpp_lib_path == None:
+                cpp_lib_path = '/home/luigi/IdeaProjects/OpenKE_new_Spark/release/Base.so'
+            base_file = os.path.abspath(cpp_lib_path)
+
+            self.lib = ctypes.cdll.LoadLibrary(base_file)
+            self.lib.sampling.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int64, ctypes.c_int64, ctypes.c_int64]
+            self.lib.getHeadBatch.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p]
+            self.lib.getTailBatch.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p]
+            self.lib.testHead.argtypes = [ctypes.c_void_p]
+            self.lib.testTail.argtypes = [ctypes.c_void_p]
+            self.lib.getTestBatch.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p]
+            self.lib.getValidBatch.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p]
+            self.lib.getBestThreshold.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p]
+            self.lib.test_triple_classification.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p]
+            self.test_flag = False
+            self.in_path = None
+            self.out_path = None
+            self.bern = 0
+
+            #EDIT
+            self.constrainFlag = 0
+
+            self.hidden_size = 100
+            self.ent_size = self.hidden_size
+            self.rel_size = self.hidden_size
+            self.train_times = 0
+            self.margin = 1.0
+            self.nbatches = 100
+            self.negative_ent = 1
+            self.negative_rel = 0
+            self.workThreads = 8
+            self.alpha = 0.001
+            self.lmbda = 0.000
+            self.log_on = 1
+            self.exportName = None
+            self.importName = None
+            self.export_steps = 0
+            self.opt_method = "SGD"
+            self.optimizer = None
+            self.test_link_prediction = False
+            self.test_triple_classification = False
+            self.valid_triple_classification = False
+            self.early_stopping = None # It expects a tuple of the following: (patience, min_delta)
+
+    def init_link_prediction(self):
+        r'''
+        import essential files and set essential interfaces for link prediction
+        '''
+        self.lib.importTestFiles()
+        self.lib.importTypeFiles()
+        self.test_h = np.zeros(self.lib.getEntityTotal(), dtype = np.int64)
+        self.test_t = np.zeros(self.lib.getEntityTotal(), dtype = np.int64)
+        self.test_r = np.zeros(self.lib.getEntityTotal(), dtype = np.int64)
+        self.test_h_addr = self.test_h.__array_interface__['data'][0]
+        self.test_t_addr = self.test_t.__array_interface__['data'][0]
+        self.test_r_addr = self.test_r.__array_interface__['data'][0]
+
+    def init_triple_classification(self):
+        r'''
+        import essential files and set essential interfaces for triple classification
+        '''
+        self.lib.importTestFiles()
+        self.lib.importTypeFiles()
+
+
+        #EDIT
+        self.acc = np.zeros(1, dtype = np.float32)
+        self.acc_addr = self.acc.__array_interface__['data'][0]
+
+        self.test_pos_h = np.zeros(self.lib.getTestTotal(), dtype = np.int64)
+        self.test_pos_t = np.zeros(self.lib.getTestTotal(), dtype = np.int64)
+        self.test_pos_r = np.zeros(self.lib.getTestTotal(), dtype = np.int64)
+        self.test_neg_h = np.zeros(self.lib.getTestTotal(), dtype = np.int64)
+        self.test_neg_t = np.zeros(self.lib.getTestTotal(), dtype = np.int64)
+        self.test_neg_r = np.zeros(self.lib.getTestTotal(), dtype = np.int64)
+        self.test_pos_h_addr = self.test_pos_h.__array_interface__['data'][0]
+        self.test_pos_t_addr = self.test_pos_t.__array_interface__['data'][0]
+        self.test_pos_r_addr = self.test_pos_r.__array_interface__['data'][0]
+        self.test_neg_h_addr = self.test_neg_h.__array_interface__['data'][0]
+        self.test_neg_t_addr = self.test_neg_t.__array_interface__['data'][0]
+        self.test_neg_r_addr = self.test_neg_r.__array_interface__['data'][0]
+
+        self.valid_pos_h = np.zeros(self.lib.getValidTotal(), dtype = np.int64)
+        self.valid_pos_t = np.zeros(self.lib.getValidTotal(), dtype = np.int64)
+        self.valid_pos_r = np.zeros(self.lib.getValidTotal(), dtype = np.int64)
+        self.valid_neg_h = np.zeros(self.lib.getValidTotal(), dtype = np.int64)
+        self.valid_neg_t = np.zeros(self.lib.getValidTotal(), dtype = np.int64)
+        self.valid_neg_r = np.zeros(self.lib.getValidTotal(), dtype = np.int64)
+        self.valid_pos_h_addr = self.valid_pos_h.__array_interface__['data'][0]
+        self.valid_pos_t_addr = self.valid_pos_t.__array_interface__['data'][0]
+        self.valid_pos_r_addr = self.valid_pos_r.__array_interface__['data'][0]
+        self.valid_neg_h_addr = self.valid_neg_h.__array_interface__['data'][0]
+        self.valid_neg_t_addr = self.valid_neg_t.__array_interface__['data'][0]
+        self.valid_neg_r_addr = self.valid_neg_r.__array_interface__['data'][0]
+
+        self.relThresh = np.zeros(self.lib.getRelationTotal(), dtype = np.float32)
+        self.relThresh_addr = self.relThresh.__array_interface__['data'][0]
+
+    #EDIT
+    def init_valid_triple_classification(self):
+        self.lib.importTestFiles()
+        self.lib.importTypeFiles()
+
+        self.acc = np.zeros(1, dtype = np.float32)
+        self.acc_addr = self.acc.__array_interface__['data'][0]
+
+        self.valid_pos_h = np.zeros(self.lib.getValidTotal(), dtype = np.int64)
+        self.valid_pos_t = np.zeros(self.lib.getValidTotal(), dtype = np.int64)
+        self.valid_pos_r = np.zeros(self.lib.getValidTotal(), dtype = np.int64)
+        self.valid_neg_h = np.zeros(self.lib.getValidTotal(), dtype = np.int64)
+        self.valid_neg_t = np.zeros(self.lib.getValidTotal(), dtype = np.int64)
+        self.valid_neg_r = np.zeros(self.lib.getValidTotal(), dtype = np.int64)
+
+        self.valid_pos_h_addr = self.valid_pos_h.__array_interface__['data'][0]
+        self.valid_pos_t_addr = self.valid_pos_t.__array_interface__['data'][0]
+        self.valid_pos_r_addr = self.valid_pos_r.__array_interface__['data'][0]
+        self.valid_neg_h_addr = self.valid_neg_h.__array_interface__['data'][0]
+        self.valid_neg_t_addr = self.valid_neg_t.__array_interface__['data'][0]
+        self.valid_neg_r_addr = self.valid_neg_r.__array_interface__['data'][0]
+
+        self.relThresh = np.zeros(self.lib.getRelationTotal(), dtype = np.float32)
+        self.relThresh_addr = self.relThresh.__array_interface__['data'][0]
+
+
+    # prepare for train and test
+    def init(self):
+        #EDIT
+        if self.init_new_entities == False:
+
+            self.trainModel = None
+            if self.in_path != None:
+                self.lib.setInPath(ctypes.create_string_buffer(self.in_path.encode(), len(self.in_path) * 2))
+                self.lib.setBern(self.bern)
+
+                #EDIT
+                self.lib.setConstrainFlag(self.constrainFlag)
+
+                self.lib.setWorkThreads(self.workThreads)
+                self.lib.randReset()
+                self.lib.importTrainFiles()
+                self.relTotal = self.lib.getRelationTotal()
+                self.entTotal = self.lib.getEntityTotal()
+
+                #EDIT
+                # self.trainTotal = self.lib.getTrainTotal()
+                self.trainTotal = self.lib.getTrainTotal_()
+
+                self.testTotal = self.lib.getTestTotal()
+                self.validTotal = self.lib.getValidTotal()
+
+                #EDIT
+                # self.batch_size = int(self.lib.getTrainTotal() / self.nbatches)
+                self.bt = self.lib.getBatchTotal()
+                tot = None
+                if self.bt > 0:
+                    tot = self.bt
+                else:
+                    tot = self.trainTotal
+
+                if self.nbatches > 0:
+                    self.batch_size = int(tot / self.nbatches)
+                else:
+                    self.batch_size = tot
+                    while self.batch_size > 9999:
+                        self.batch_size = int(self.batch_size / 10)
+                    self.nbatches = int(tot / self.batch_size)
+
+                print("Batch size is {}".format(self.batch_size))
+                print("Number of batches: {}".format(self.nbatches))
+
+
+                self.batch_seq_size = self.batch_size * (1 + self.negative_ent + self.negative_rel)
+                self.batch_h = np.zeros(self.batch_size * (1 + self.negative_ent + self.negative_rel), dtype = np.int64)
+                self.batch_t = np.zeros(self.batch_size * (1 + self.negative_ent + self.negative_rel), dtype = np.int64)
+                self.batch_r = np.zeros(self.batch_size * (1 + self.negative_ent + self.negative_rel), dtype = np.int64)
+                self.batch_y = np.zeros(self.batch_size * (1 + self.negative_ent + self.negative_rel), dtype = np.float32)
+                self.batch_h_addr = self.batch_h.__array_interface__['data'][0]
+                self.batch_t_addr = self.batch_t.__array_interface__['data'][0]
+                self.batch_r_addr = self.batch_r.__array_interface__['data'][0]
+                self.batch_y_addr = self.batch_y.__array_interface__['data'][0]
+
+
+            if self.test_link_prediction:
+                self.init_link_prediction()
+            if self.test_triple_classification:
+                self.init_triple_classification()
+            #EDIT
+            if self.valid_triple_classification:
+                self.init_valid_triple_classification()
+
+    def get_ent_total(self):
+        return self.entTotal
+
+    def get_rel_total(self):
+        return self.relTotal
+
+    def set_lmbda(self, lmbda):
+        self.lmbda = lmbda
+
+    def set_optimizer(self, optimizer):
+        self.optimizer = optimizer
+
+    def set_opt_method(self, method):
+        self.opt_method = method
+
+    def set_test_link_prediction(self, flag):
+        self.test_link_prediction = flag
+
+    def set_test_triple_classification(self, flag):
+        self.test_triple_classification = flag
+
+    #EDIT
+    def set_valid_triple_classification(self, flag):
+        self.valid_triple_classification = flag
+
+    def set_log_on(self, flag):
+        self.log_on = flag
+
+    def set_alpha(self, alpha):
+        self.alpha = alpha
+
+    def set_in_path(self, path):
+        self.in_path = path
+
+    def set_out_files(self, path):
+        self.out_path = path
+
+    def set_bern(self, bern):
+        self.bern = bern
+
+    #EDIT
+    def set_constrain_flag(self, constrainFlag):
+        self.constrainFlag = constrainFlag
+
+    def set_dimension(self, dim):
+        self.hidden_size = dim
+        self.ent_size = dim
+        self.rel_size = dim
+
+    def set_ent_dimension(self, dim):
+        self.ent_size = dim
+
+    def set_rel_dimension(self, dim):
+        self.rel_size = dim
+
+    def set_train_times(self, times):
+        self.train_times = times
+
+    def set_nbatches(self, nbatches):
+        self.nbatches = nbatches
+
+    def set_margin(self, margin):
+        self.margin = margin
+
+    # def set_work_threads(self, threads):
+    #     self.workThreads = threads
+
+    def set_ent_neg_rate(self, rate):
+        self.negative_ent = rate
+
+    def set_rel_neg_rate(self, rate):
+        self.negative_rel = rate
+
+    def set_import_files(self, path):
+        self.importName = path
+
+    def set_export_files(self, path, steps = 0):
+        self.exportName = path
+        self.export_steps = steps
+
+    def set_export_steps(self, steps):
+        self.export_steps = steps
+
+    def set_early_stopping(self, early_stopping):
+        self.early_stopping = early_stopping
+
+    # call C function for sampling
+    def sampling(self):
+        self.lib.sampling(self.batch_h_addr, self.batch_t_addr, self.batch_r_addr, self.batch_y_addr, self.batch_size, self.negative_ent, self.negative_rel)
+
+    # save model
+    def save_tensorflow(self):
+        with self.graph.as_default():
+            with self.sess.as_default():
+                self.saver.save(self.sess, self.exportName)
+
+    #EDIT
+    def save_tensorflow_weights(self, export_name=None, write_meta_graph=False):
+        if export_name == None:
+            export_name = self.exportName
+        with self.graph.as_default():
+            with self.sess.as_default():
+                self.saver.save(self.sess, export_name, write_meta_graph=write_meta_graph, write_state=False)
+
+    # restore model
+    def restore_tensorflow(self):
+        with self.graph.as_default():
+            with self.sess.as_default():
+                self.saver.restore(self.sess, self.importName)
+
+
+    def export_variables(self, path = None):
+        with self.graph.as_default():
+            with self.sess.as_default():
+                if path == None:
+                    self.saver.save(self.sess, self.exportName)
+                else:
+                    self.saver.save(self.sess, path)
+
+    def import_variables(self, path = None):
+        with self.graph.as_default():
+            with self.sess.as_default():
+                if path == None:
+                    self.saver.restore(self.sess, self.importName)
+                else:
+                    self.saver.restore(self.sess, path)
+
+    def get_parameter_lists(self):
+        return self.trainModel.parameter_lists
+
+    def get_parameters_by_name(self, var_name):
+        with self.graph.as_default():
+            with self.sess.as_default():
+                if var_name in self.trainModel.parameter_lists:
+                    return self.sess.run(self.trainModel.parameter_lists[var_name])
+                else:
+                    return None
+
+    def get_parameters(self, mode = "numpy"):
+        res = {}
+        lists = self.get_parameter_lists()
+        for var_name in lists:
+            if mode == "numpy":
+                res[var_name] = self.get_parameters_by_name(var_name)
+            else:
+                res[var_name] = self.get_parameters_by_name(var_name).tolist()
+        return res
+
+    def save_parameters(self, path = None):
+        if path == None:
+            path = self.out_path
+        f = open(path, "w")
+        f.write(json.dumps(self.get_parameters("list")))
+        f.close()
+
+    def set_parameters_by_name(self, var_name, tensor):
+        with self.graph.as_default():
+            with self.sess.as_default():
+                if var_name in self.trainModel.parameter_lists:
+                    self.trainModel.parameter_lists[var_name].assign(tensor).eval()
+
+    def set_parameters(self, lists):
+        for i in lists:
+            self.set_parameters_by_name(i, lists[i])
+
+    #EDIT
+    # def set_model(self, model):
+    # 	self.model = model
+    # 	self.graph = tf.Graph()
+    # 	with self.graph.as_default():
+    # 		self.sess = tf.Session()
+    # 		with self.sess.as_default():
+    # 			initializer = tf.contrib.layers.xavier_initializer(uniform = True)
+    # 			with tf.variable_scope("model", reuse=None, initializer = initializer):
+    # 				self.trainModel = self.model(config = self)
+    # 				if self.optimizer != None:
+    # 					pass
+    # 				elif self.opt_method == "Adagrad" or self.opt_method == "adagrad":
+    # 					self.optimizer = tf.train.AdagradOptimizer(learning_rate = self.alpha, initial_accumulator_value=1e-20)
+    # 				elif self.opt_method == "Adadelta" or self.opt_method == "adadelta":
+    # 					self.optimizer = tf.train.AdadeltaOptimizer(self.alpha)
+    # 				elif self.opt_method == "Adam" or self.opt_method == "adam":
+    # 					self.optimizer = tf.train.AdamOptimizer(self.alpha)
+    # 				else:
+    # 					self.optimizer = tf.train.GradientDescentOptimizer(self.alpha)
+    # 				grads_and_vars = self.optimizer.compute_gradients(self.trainModel.loss)
+    # 				self.train_op = self.optimizer.apply_gradients(grads_and_vars)
+    # 			self.saver = tf.train.Saver()
+    # 			self.sess.run(tf.global_variables_initializer())
+
+
+    def set_model(self, model):
+        self.model = model
+
+
+    #EDIT
+    def import_model(self, ckpt):
+        self.graph = tf.Graph()
+        with self.graph.as_default():
+            self.sess = tf.Session()
+            with self.sess.as_default():
+                print("Importing metagraph...")
+                self.saver = tf.train.import_meta_graph(ckpt+".meta", clear_devices=True)
+                print("Importing variables...")
+                self.saver.restore(self.sess, ckpt)
+
+    #EDIT
+    def set_model_and_session(self, model):
+        self.model = model
+        self.graph = tf.Graph()
+        with self.graph.as_default():
+            self.sess = tf.Session()
+            with self.sess.as_default():
+                initializer = tf.contrib.layers.xavier_initializer(uniform = True)
+                with tf.variable_scope("", reuse=None, initializer = initializer):
+                    self.trainModel = self.model(config = self, define=True)
+                self.saver = tf.train.Saver()
+                self.sess.run(tf.initialize_all_variables())
+
+
+    def train_step(self, batch_h, batch_t, batch_r, batch_y):
+        feed_dict = {
+            self.trainModel.batch_h: batch_h,
+            self.trainModel.batch_t: batch_t,
+            self.trainModel.batch_r: batch_r,
+            self.trainModel.batch_y: batch_y
+        }
+        _, loss = self.sess.run([self.train_op, self.trainModel.loss], feed_dict)
+        return loss
+
+
+    def test_step(self, test_h, test_t, test_r):
+        feed_dict = {
+            self.trainModel.predict_h: test_h,
+            self.trainModel.predict_t: test_t,
+            self.trainModel.predict_r: test_r,
+        }
+        predict = self.sess.run(self.trainModel.predict, feed_dict)
+        return predict
+
+
+    #EDIT
+    # def run(self):
+    # 	with self.graph.as_default():
+    # 		with self.sess.as_default():
+    # 			if self.importName != None:
+    # 				self.restore_tensorflow()
+    # 			if self.early_stopping is not None:
+    # 				patience, min_delta = self.early_stopping
+    # 				best_loss = np.finfo('float32').max
+    # 				wait_steps = 0
+    # 			for times in range(self.train_times):
+    # 				loss = 0.0
+    # 				t_init = time.time()
+    # 				for batch in range(self.nbatches):
+    # 					self.sampling()
+    # 					loss += self.train_step(self.batch_h, self.batch_t, self.batch_r, self.batch_y)
+    # 				t_end = time.time()
+    # 				if self.log_on:
+    # 					print('Epoch: {}, loss: {}, time: {}'.format(times, loss, (t_end - t_init)))
+    # 				if self.exportName != None and (self.export_steps!=0 and times % self.export_steps == 0):
+    # 					self.save_tensorflow()
+    # 				if self.early_stopping is not None:
+    # 					if loss + min_delta < best_loss:
+    # 						best_loss = loss
+    # 						wait_steps = 0
+    # 					elif wait_steps < patience:
+    # 						wait_steps += 1
+    # 					else:
+    # 						print('Early stopping. Losses have not been improved enough in {} times'.format(patience))
+    # 						break
+    # 			if self.exportName != None:
+    # 				self.save_tensorflow()
+    # 			if self.out_path != None:
+    # 				self.save_parameters(self.out_path)
+
+
+
+
+    def test(self):
+        with self.graph.as_default():
+            with self.sess.as_default():
+                if self.importName != None:
+                    self.restore_tensorflow()
+                if self.test_link_prediction:
+                    total = self.lib.getTestTotal()
+                    for times in range(total):
+                        self.lib.getHeadBatch(self.test_h_addr, self.test_t_addr, self.test_r_addr)
+                        res = self.test_step(self.test_h, self.test_t, self.test_r)
+                        self.lib.testHead(res.__array_interface__['data'][0])
+
+                        self.lib.getTailBatch(self.test_h_addr, self.test_t_addr, self.test_r_addr)
+                        res = self.test_step(self.test_h, self.test_t, self.test_r)
+                        self.lib.testTail(res.__array_interface__['data'][0])
+                        if self.log_on:
+                            #EDIT
+                            # print(times)
+                            sys.stdout.write("\r# of test triples processed: {}/{}".format(times, total))
+
+                    self.lib.test_link_prediction()
+                if self.test_triple_classification:
+                    self.lib.getValidBatch(self.valid_pos_h_addr, self.valid_pos_t_addr, self.valid_pos_r_addr, self.valid_neg_h_addr, self.valid_neg_t_addr, self.valid_neg_r_addr)
+                    res_pos = self.test_step(self.valid_pos_h, self.valid_pos_t, self.valid_pos_r)
+                    res_neg = self.test_step(self.valid_neg_h, self.valid_neg_t, self.valid_neg_r)
+                    self.lib.getBestThreshold(self.relThresh_addr, res_pos.__array_interface__['data'][0], res_neg.__array_interface__['data'][0])
+
+                    self.lib.getTestBatch(self.test_pos_h_addr, self.test_pos_t_addr, self.test_pos_r_addr, self.test_neg_h_addr, self.test_neg_t_addr, self.test_neg_r_addr)
+
+                    res_pos = self.test_step(self.test_pos_h, self.test_pos_t, self.test_pos_r)
+                    res_neg = self.test_step(self.test_neg_h, self.test_neg_t, self.test_neg_r)
+                    #EDIT
+                    self.lib.test_triple_classification(self.relThresh_addr, res_pos.__array_interface__['data'][0], res_neg.__array_interface__['data'][0], self.acc_addr)
+
+    #EDIT
+    def valid(self):
+        with self.graph.as_default():
+            with self.sess.as_default():
+                if self.importName != None:
+                    self.restore_tensorflow()
+                self.lib.getValidBatch(self.valid_pos_h_addr, self.valid_pos_t_addr, self.valid_pos_r_addr, self.valid_neg_h_addr, self.valid_neg_t_addr, self.valid_neg_r_addr)
+                res_pos = self.test_step(self.valid_pos_h, self.valid_pos_t, self.valid_pos_r)
+                res_neg = self.test_step(self.valid_neg_h, self.valid_neg_t, self.valid_neg_r)
+                self.lib.getBestThreshold(self.relThresh_addr, res_pos.__array_interface__['data'][0], res_neg.__array_interface__['data'][0])
+
+                self.lib.test_triple_classification(self.relThresh_addr, res_pos.__array_interface__['data'][0], res_neg.__array_interface__['data'][0], self.acc_addr)
+
+
+
+    def predict_head_entity(self, t, r, k):
+        r'''This mothod predicts the top k head entities given tail entity and relation.
+
+        Args:
+            t (int): tail entity id
+            r (int): relation id
+            k (int): top k head entities
+
+        Returns:
+            list: k possible head entity ids
+        '''
+        self.init_link_prediction()
+        if self.importName != None:
+            self.restore_tensorflow()
+        test_h = np.array(range(self.entTotal))
+        test_r = np.array([r] * self.entTotal)
+        test_t = np.array([t] * self.entTotal)
+        res = self.test_step(test_h, test_t, test_r).reshape(-1).argsort()[:k]
+        print(res)
+        return res
+
+
+    def predict_tail_entity(self, h, r, k):
+        r'''This mothod predicts the top k tail entities given head entity and relation.
+
+        Args:
+            h (int): head entity id
+            r (int): relation id
+            k (int): top k tail entities
+
+        Returns:
+            list: k possible tail entity ids
+        '''
+        self.init_link_prediction()
+        if self.importName != None:
+            self.restore_tensorflow()
+        test_h = np.array([h] * self.entTotal)
+        test_r = np.array([r] * self.entTotal)
+        test_t = np.array(range(self.entTotal))
+        res = self.test_step(test_h, test_t, test_r).reshape(-1).argsort()[:k]
+        print(res)
+        return res
+
+    def predict_relation(self, h, t, k):
+        r'''This methods predict the relation id given head entity and tail entity.
+
+        Args:
+            h (int): head entity id
+            t (int): tail entity id
+            k (int): top k relations
+
+        Returns:
+            list: k possible relation ids
+        '''
+        self.init_link_prediction()
+        if self.importName != None:
+            self.restore_tensorflow()
+        test_h = np.array([h] * self.relTotal)
+        test_r = np.array(range(self.relTotal))
+        test_t = np.array([t] * self.relTotal)
+        res = self.test_step(test_h, test_t, test_r).reshape(-1).argsort()[:k]
+        print(res)
+        return res
+
+    def predict_triple(self, h, t, r, thresh = None):
+        r'''This method tells you whether the given triple (h, t, r) is correct of wrong
+
+        Args:
+            h (int): head entity id
+            t (int): tail entity id
+            r (int): relation id
+            thresh (fload): threshold for the triple
+        '''
+        self.init_triple_classification()
+        if self.importName != None:
+            self.restore_tensorflow()
+        res = self.test_step(np.array([h]), np.array([t]), np.array([r]))
+        if thresh != None:
+            if res < thresh:
+                print("triple (%d,%d,%d) is correct" % (h, t, r))
+            else:
+                print("triple (%d,%d,%d) is wrong" % (h, t, r))
+            return
+        self.lib.getValidBatch(self.valid_pos_h_addr, self.valid_pos_t_addr, self.valid_pos_r_addr, self.valid_neg_h_addr, self.valid_neg_t_addr, self.valid_neg_r_addr)
+        res_pos = self.test_step(self.valid_pos_h, self.valid_pos_t, self.valid_pos_r)
+        res_neg = self.test_step(self.valid_neg_h, self.valid_neg_t, self.valid_neg_r)
+        self.lib.getBestThreshold(self.relThresh_addr, res_pos.__array_interface__['data'][0], res_neg.__array_interface__['data'][0])
+        if res < self.relThresh[r]:
+            print("triple (%d,%d,%d) is correct" % (h, t, r))
+        else:
+            print("triple (%d,%d,%d) is wrong" % (h, t, r))
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..13ab296
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 THUNLP
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/Model.py b/Model.py
new file mode 100644
index 0000000..08d2337
--- /dev/null
+++ b/Model.py
@@ -0,0 +1,99 @@
+#coding:utf-8
+import numpy as np
+import tensorflow as tf
+
+class Model(object):
+
+	def get_config(self):
+		return self.config
+
+	def get_positive_instance(self, in_batch = True):
+		if in_batch:
+			return [self.positive_h, self.positive_t, self.positive_r]
+		else:
+			return [self.batch_h[0:self.config.batch_size], \
+			self.batch_t[0:self.config.batch_size], \
+			self.batch_r[0:self.config.batch_size]]
+
+	def get_negative_instance(self, in_batch = True):
+		if in_batch:
+			return [self.negative_h, self.negative_t, self.negative_r]
+		else:
+			return [self.batch_h[self.config.batch_size:self.config.batch_seq_size],\
+			self.batch_t[self.config.batch_size:self.config.batch_seq_size],\
+			self.batch_r[self.config.batch_size:self.config.batch_seq_size]]
+
+	def get_positive_labels(self, in_batch = True):
+		if in_batch:
+			return self.positive_y
+		else:
+			return self.batch_y[0:self.config.batch_size]
+
+	def get_negative_labels(self, in_batch = True):
+		if in_batch:
+			return self.negative_y
+		else:
+			return self.batch_y[self.config.batch_size:self.config.batch_seq_size]
+
+	def get_all_instance(self, in_batch = False):
+		if in_batch:
+			return [tf.transpose(tf.reshape(self.batch_h, [1 + self.config.negative_ent + self.config.negative_rel, -1]), [1, 0]),\
+			tf.transpose(tf.reshape(self.batch_t, [1 + self.config.negative_ent + self.config.negative_rel, -1]), [1, 0]),\
+			tf.transpose(tf.reshape(self.batch_r, [1 + self.config.negative_ent + self.config.negative_rel, -1]), [1, 0])]
+		else:
+			return [self.batch_h, self.batch_t, self.batch_r]
+
+	def get_all_labels(self, in_batch = False):
+		if in_batch:
+			return tf.transpose(tf.reshape(self.batch_y, [1 + self.config.negative_ent + self.config.negative_rel, -1]), [1, 0])
+		else:
+			return self.batch_y
+
+	def get_predict_instance(self):
+		return [self.predict_h, self.predict_t, self.predict_r]
+
+	def input_def(self):
+		config = self.config
+		self.batch_h = tf.placeholder(tf.int64, [config.batch_seq_size])
+		self.batch_t = tf.placeholder(tf.int64, [config.batch_seq_size])
+		self.batch_r = tf.placeholder(tf.int64, [config.batch_seq_size])
+		self.batch_y = tf.placeholder(tf.float32, [config.batch_seq_size])
+
+		self.positive_h = tf.transpose(tf.reshape(self.batch_h[0:config.batch_size], [1, -1]), perm = [1, 0])
+		self.positive_t = tf.transpose(tf.reshape(self.batch_t[0:config.batch_size], [1, -1]), perm = [1, 0])
+		self.positive_r = tf.transpose(tf.reshape(self.batch_r[0:config.batch_size], [1, -1]), perm = [1, 0])
+		self.positive_y = tf.transpose(tf.reshape(self.batch_y[0:config.batch_size], [1, -1]), perm = [1, 0])
+		self.negative_h = tf.transpose(tf.reshape(self.batch_h[config.batch_size:config.batch_seq_size], [config.negative_ent + config.negative_rel, -1]), perm = [1, 0])
+		self.negative_t = tf.transpose(tf.reshape(self.batch_t[config.batch_size:config.batch_seq_size], [config.negative_ent + config.negative_rel, -1]), perm = [1, 0])
+		self.negative_r = tf.transpose(tf.reshape(self.batch_r[config.batch_size:config.batch_seq_size], [config.negative_ent + config.negative_rel, -1]), perm = [1, 0])
+		self.negative_y = tf.transpose(tf.reshape(self.batch_y[config.batch_size:config.batch_seq_size], [config.negative_ent + config.negative_rel, -1]), perm = [1, 0])
+		
+		self.predict_h = tf.placeholder(tf.int64, [None])
+		self.predict_t = tf.placeholder(tf.int64, [None])
+		self.predict_r = tf.placeholder(tf.int64, [None])
+		self.parameter_lists = []
+
+	def embedding_def(self):
+		pass
+
+	def loss_def(self):
+		pass
+
+	def predict_def(self):
+		pass
+
+	def __init__(self, config, define=False):
+		self.config = config
+
+		if define:
+			with tf.name_scope("input"):
+				self.input_def()
+
+			with tf.name_scope("embedding"):
+				self.embedding_def()
+
+			with tf.name_scope("loss"):
+				self.loss_def()
+
+			with tf.name_scope("predict"):
+				self.predict_def()
diff --git a/OpenKE_new_Spark.iml b/OpenKE_new_Spark.iml
new file mode 100644
index 0000000..8021953
--- /dev/null
+++ b/OpenKE_new_Spark.iml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..8c25190
--- /dev/null
+++ b/README.md
@@ -0,0 +1,2 @@
+# OpenKEonSpark
+This is a distributed version of the framework OpenKE (https://github.com/thunlp/OpenKE) using the library TensorFlowOnSpark (https://github.com/yahoo/TensorFlowOnSpark).
diff --git a/TransD.py b/TransD.py
new file mode 100644
index 0000000..3ac5cd1
--- /dev/null
+++ b/TransD.py
@@ -0,0 +1,98 @@
+#coding:utf-8
+import numpy as np
+import tensorflow as tf
+from Model import Model
+
+def tf_resize(tensor, axis, size):
+	shape = tensor.get_shape().as_list()
+	osize = shape[axis]
+	if osize == size:
+		return tensor
+	if (osize > size):
+		shape[axis] = size
+		return tf.slice(tensor, begin = (0,) * len(shape), size = shape)
+	paddings = [[0, 0] for i in range(len(shape))]
+	paddings[axis][1] = size - osize
+	return tf.pad(tensor, paddings = paddings)
+
+class TransD(Model):
+	r'''
+	TransD constructs a dynamic mapping matrix for each entity-relation pair by considering the diversity of entities and relations simultaneously. 
+	Compared with TransR/CTransR, TransD has fewer parameters and has no matrix vector multiplication.
+	'''
+	def _transfer(self, e, t, r):
+		# return e + tf.reduce_sum(e * t, -1, keep_dims = True) * r
+		return tf_resize(e, -1, r.get_shape()[-1]) + tf.reduce_sum(e * t, -1, keepdims = True) * r
+
+	def _calc(self, h, t, r):
+		h = tf.nn.l2_normalize(h, -1)
+		t = tf.nn.l2_normalize(t, -1)
+		r = tf.nn.l2_normalize(r, -1)
+		return abs(h + r - t)
+
+	def embedding_def(self):
+		#Obtaining the initial configuration of the model
+		config = self.get_config()
+		#Defining required parameters of the model, including embeddings of entities and relations, entity transfer vectors, and relation transfer vectors
+		self.ent_embeddings = tf.get_variable(name = "ent_embeddings", shape = [config.entTotal, config.hidden_size], initializer = tf.contrib.layers.xavier_initializer(uniform = False))
+		self.rel_embeddings = tf.get_variable(name = "rel_embeddings", shape = [config.relTotal, config.hidden_size], initializer = tf.contrib.layers.xavier_initializer(uniform = False))
+		self.ent_transfer = tf.get_variable(name = "ent_transfer", shape = [config.entTotal, config.hidden_size], initializer = tf.contrib.layers.xavier_initializer(uniform = False))
+		self.rel_transfer = tf.get_variable(name = "rel_transfer", shape = [config.relTotal, config.hidden_size], initializer = tf.contrib.layers.xavier_initializer(uniform = False))
+		self.parameter_lists = {"ent_embeddings":self.ent_embeddings, \
+								"rel_embeddings":self.rel_embeddings, \
+								"ent_transfer":self.ent_transfer, \
+								"rel_transfer":self.rel_transfer}
+
+	def loss_def(self):
+		#Obtaining the initial configuration of the model
+		config = self.get_config()
+		#To get positive triples and negative triples for training
+		#The shapes of pos_h, pos_t, pos_r are (batch_size, 1)
+		#The shapes of neg_h, neg_t, neg_r are (batch_size, negative_ent + negative_rel)
+		pos_h, pos_t, pos_r = self.get_positive_instance(in_batch = True)
+		neg_h, neg_t, neg_r = self.get_negative_instance(in_batch = True)
+		#Embedding entities and relations of triples, e.g. pos_h_e, pos_t_e and pos_r_e are embeddings for positive triples
+		pos_h_e = tf.nn.embedding_lookup(self.ent_embeddings, pos_h)
+		pos_t_e = tf.nn.embedding_lookup(self.ent_embeddings, pos_t)
+		pos_r_e = tf.nn.embedding_lookup(self.rel_embeddings, pos_r)
+		neg_h_e = tf.nn.embedding_lookup(self.ent_embeddings, neg_h)
+		neg_t_e = tf.nn.embedding_lookup(self.ent_embeddings, neg_t)
+		neg_r_e = tf.nn.embedding_lookup(self.rel_embeddings, neg_r)
+		#Getting the required parameters to transfer entity embeddings, e.g. pos_h_t, pos_t_t and pos_r_t are transfer parameters for positive triples
+		pos_h_t = tf.nn.embedding_lookup(self.ent_transfer, pos_h)
+		pos_t_t = tf.nn.embedding_lookup(self.ent_transfer, pos_t)
+		pos_r_t = tf.nn.embedding_lookup(self.rel_transfer, pos_r)
+		neg_h_t = tf.nn.embedding_lookup(self.ent_transfer, neg_h)
+		neg_t_t = tf.nn.embedding_lookup(self.ent_transfer, neg_t)
+		neg_r_t = tf.nn.embedding_lookup(self.rel_transfer, neg_r)
+		#Calculating score functions for all positive triples and negative triples
+		p_h = self._transfer(pos_h_e, pos_h_t, pos_r_t)
+		p_t = self._transfer(pos_t_e, pos_t_t, pos_r_t)
+		p_r = pos_r_e
+		n_h = self._transfer(neg_h_e, neg_h_t, neg_r_t)
+		n_t = self._transfer(neg_t_e, neg_t_t, neg_r_t)
+		n_r = neg_r_e
+		#The shape of _p_score is (batch_size, 1, hidden_size)
+		#The shape of _n_score is (batch_size, negative_ent + negative_rel, hidden_size)
+		_p_score = self._calc(p_h, p_t, p_r)
+		_n_score = self._calc(n_h, n_t, n_r)
+		#The shape of p_score is (batch_size, 1, 1)
+		#The shape of n_score is (batch_size, negative_ent + negative_rel, 1)
+		p_score =  tf.reduce_sum(_p_score, -1, keep_dims = True)
+		n_score =  tf.reduce_sum(_n_score, -1, keep_dims = True)
+		#Calculating loss to get what the framework will optimize
+		self.loss = tf.reduce_mean(tf.maximum(p_score - n_score + config.margin, 0))
+
+	def predict_def(self):
+		config = self.get_config()
+		predict_h, predict_t, predict_r = self.get_predict_instance()
+		predict_h_e = tf.nn.embedding_lookup(self.ent_embeddings, predict_h)
+		predict_t_e = tf.nn.embedding_lookup(self.ent_embeddings, predict_t)
+		predict_r_e = tf.nn.embedding_lookup(self.rel_embeddings, predict_r)
+		predict_h_t = tf.nn.embedding_lookup(self.ent_transfer, predict_h)
+		predict_t_t = tf.nn.embedding_lookup(self.ent_transfer, predict_t)
+		predict_r_t = tf.nn.embedding_lookup(self.rel_transfer, predict_r)
+		h_e = self._transfer(predict_h_e, predict_h_t, predict_r_t)
+		t_e = self._transfer(predict_t_e, predict_t_t, predict_r_t)
+		r_e = predict_r_e
+		self.predict = tf.reduce_sum(self._calc(h_e, t_e, r_e), -1, keep_dims = True)
diff --git a/TransE.py b/TransE.py
new file mode 100644
index 0000000..8810365
--- /dev/null
+++ b/TransE.py
@@ -0,0 +1,58 @@
+#coding:utf-8
+import numpy as np
+import tensorflow as tf
+from Model import Model
+
+class TransE(Model):
+    r'''
+    TransE is the first model to introduce translation-based embedding,
+    which interprets relations as the translations operating on entities.
+    '''
+    def _calc(self, h, t, r):
+        h = tf.nn.l2_normalize(h, -1)
+        t = tf.nn.l2_normalize(t, -1)
+        r = tf.nn.l2_normalize(r, -1)
+        return abs(h + r - t)
+
+    def embedding_def(self):
+        #Obtaining the initial configuration of the model
+        config = self.get_config()
+        #Defining required parameters of the model, including embeddings of entities and relations
+        self.ent_embeddings = tf.get_variable(name = "ent_embeddings", shape = [config.entTotal, config.hidden_size], initializer = tf.contrib.layers.xavier_initializer(uniform = False))
+        self.rel_embeddings = tf.get_variable(name = "rel_embeddings", shape = [config.relTotal, config.hidden_size], initializer = tf.contrib.layers.xavier_initializer(uniform = False))
+        self.parameter_lists = {"ent_embeddings":self.ent_embeddings, \
+                                "rel_embeddings":self.rel_embeddings}
+
+    def loss_def(self):
+        #Obtaining the initial configuration of the model
+        config = self.get_config()
+        #To get positive triples and negative triples for training
+        #The shapes of pos_h, pos_t, pos_r are (batch_size, 1)
+        #The shapes of neg_h, neg_t, neg_r are (batch_size, negative_ent + negative_rel)
+        pos_h, pos_t, pos_r = self.get_positive_instance(in_batch = True)
+        neg_h, neg_t, neg_r = self.get_negative_instance(in_batch = True)
+        #Embedding entities and relations of triples, e.g. p_h, p_t and p_r are embeddings for positive triples
+        p_h = tf.nn.embedding_lookup(self.ent_embeddings, pos_h)
+        p_t = tf.nn.embedding_lookup(self.ent_embeddings, pos_t)
+        p_r = tf.nn.embedding_lookup(self.rel_embeddings, pos_r)
+        n_h = tf.nn.embedding_lookup(self.ent_embeddings, neg_h)
+        n_t = tf.nn.embedding_lookup(self.ent_embeddings, neg_t)
+        n_r = tf.nn.embedding_lookup(self.rel_embeddings, neg_r)
+        #Calculating score functions for all positive triples and negative triples
+        #The shape of _p_score is (batch_size, 1, hidden_size)
+        #The shape of _n_score is (batch_size, negative_ent + negative_rel, hidden_size)
+        _p_score = self._calc(p_h, p_t, p_r)
+        _n_score = self._calc(n_h, n_t, n_r)
+        #The shape of p_score is (batch_size, 1, 1)
+        #The shape of n_score is (batch_size, negative_ent + negative_rel, 1)
+        p_score =  tf.reduce_sum(_p_score, -1, keep_dims = True)
+        n_score =  tf.reduce_sum(_n_score, -1, keep_dims = True)
+        #Calculating loss to get what the framework will optimize
+        self.loss = tf.reduce_mean(tf.maximum(p_score - n_score + config.margin, 0))
+
+    def predict_def(self):
+        predict_h, predict_t, predict_r = self.get_predict_instance()
+        predict_h_e = tf.nn.embedding_lookup(self.ent_embeddings, predict_h)
+        predict_t_e = tf.nn.embedding_lookup(self.ent_embeddings, predict_t)
+        predict_r_e = tf.nn.embedding_lookup(self.rel_embeddings, predict_r)
+        self.predict = tf.reduce_mean(self._calc(predict_h_e, predict_t_e, predict_r_e), 1, keep_dims = False)
\ No newline at end of file
diff --git a/TransH.py b/TransH.py
new file mode 100644
index 0000000..841d02e
--- /dev/null
+++ b/TransH.py
@@ -0,0 +1,82 @@
+
+#coding:utf-8
+import numpy as np
+import tensorflow as tf
+from Model import Model
+
+class TransH(Model):
+	r'''
+	To preserve the mapping propertities of 1-N/N-1/N-N relations, 
+	TransH inperprets a relation as a translating operation on a hyperplane. 
+	'''
+	def _transfer(self, e, n):
+		n = tf.nn.l2_normalize(n, -1)
+		return e - tf.reduce_sum(e * n, -1, keepdims = True) * n
+
+	def _calc(self, h, t, r, flag = True):
+		h = tf.nn.l2_normalize(h, -1)
+		t = tf.nn.l2_normalize(t, -1)
+		r = tf.nn.l2_normalize(r, -1)
+		return abs(h + r - t)
+
+	def embedding_def(self):
+		#Obtaining the initial configuration of the model
+		config = self.get_config()
+		#Defining required parameters of the model, including embeddings of entities and relations, and normal vectors of planes
+		self.ent_embeddings = tf.get_variable(name = "ent_embeddings", shape = [config.entTotal, config.hidden_size], initializer = tf.contrib.layers.xavier_initializer(uniform = False))
+		self.rel_embeddings = tf.get_variable(name = "rel_embeddings", shape = [config.relTotal, config.hidden_size], initializer = tf.contrib.layers.xavier_initializer(uniform = False))
+		self.normal_vectors = tf.get_variable(name = "normal_vectors", shape = [config.relTotal, config.hidden_size], initializer = tf.contrib.layers.xavier_initializer(uniform = False))
+		self.parameter_lists = {"ent_embeddings":self.ent_embeddings, \
+								"rel_embeddings":self.rel_embeddings, \
+								"normal_vectors":self.normal_vectors}
+
+	def loss_def(self):
+		#Obtaining the initial configuration of the model
+		config = self.get_config()
+		#To get positive triples and negative triples for training
+		#The shapes of pos_h, pos_t, pos_r are (batch_size, 1)
+		#The shapes of neg_h, neg_t, neg_r are (batch_size, negative_ent + negative_rel)
+		pos_h, pos_t, pos_r = self.get_positive_instance(in_batch = True)
+		neg_h, neg_t, neg_r = self.get_negative_instance(in_batch = True)
+		#Embedding entities and relations of triples, e.g. pos_h_e, pos_t_e and pos_r_e are embeddings for positive triples
+		pos_h_e = tf.nn.embedding_lookup(self.ent_embeddings, pos_h)
+		pos_t_e = tf.nn.embedding_lookup(self.ent_embeddings, pos_t)
+		pos_r_e = tf.nn.embedding_lookup(self.rel_embeddings, pos_r)
+		neg_h_e = tf.nn.embedding_lookup(self.ent_embeddings, neg_h)
+		neg_t_e = tf.nn.embedding_lookup(self.ent_embeddings, neg_t)
+		neg_r_e = tf.nn.embedding_lookup(self.rel_embeddings, neg_r)
+		#Getting the required normal vectors of planes to transfer entity embeddings
+		pos_norm = tf.nn.embedding_lookup(self.normal_vectors, pos_r)
+		neg_norm = tf.nn.embedding_lookup(self.normal_vectors, neg_r)
+
+		#Calculating score functions for all positive triples and negative triples
+		p_h = self._transfer(pos_h_e, pos_norm)
+		p_t = self._transfer(pos_t_e, pos_norm)
+		p_r = pos_r_e
+		n_h = self._transfer(neg_h_e, neg_norm)
+		n_t = self._transfer(neg_t_e, neg_norm)
+		n_r = neg_r_e
+		#Calculating score functions for all positive triples and negative triples
+		#The shape of _p_score is (batch_size, 1, hidden_size)
+		#The shape of _n_score is (batch_size, negative_ent + negative_rel, hidden_size)
+		_p_score = self._calc(p_h, p_t, p_r)
+		_n_score = self._calc(n_h, n_t, n_r)
+		#The shape of p_score is (batch_size, 1, 1)
+		#The shape of n_score is (batch_size, negative_ent + negative_rel, 1)
+		p_score =  tf.reduce_sum(_p_score, -1, keep_dims = True)
+		n_score =  tf.reduce_sum(_n_score, -1, keep_dims = True)
+		#Calculating loss to get what the framework will optimize
+		self.loss = tf.reduce_mean(tf.maximum(p_score - n_score + config.margin, 0))
+
+
+	def predict_def(self):
+		config = self.get_config()
+		predict_h, predict_t, predict_r = self.get_predict_instance()
+		predict_h_e = tf.nn.embedding_lookup(self.ent_embeddings, predict_h)
+		predict_t_e = tf.nn.embedding_lookup(self.ent_embeddings, predict_t)
+		predict_r_e = tf.nn.embedding_lookup(self.rel_embeddings, predict_r)
+		predict_norm = tf.nn.embedding_lookup(self.normal_vectors, predict_r)	
+		h_e = self._transfer(predict_h_e, predict_norm)
+		t_e = self._transfer(predict_t_e, predict_norm)
+		r_e = predict_r_e
+		self.predict = tf.reduce_sum(self._calc(h_e, t_e, r_e), -1, keepdims = True)
\ No newline at end of file
diff --git a/TransR.py b/TransR.py
new file mode 100644
index 0000000..f167e23
--- /dev/null
+++ b/TransR.py
@@ -0,0 +1,87 @@
+#coding:utf-8
+import numpy as np
+import tensorflow as tf
+from Model import Model
+
+if tf.__version__ > '0.12.1':
+	matmul_func = tf.matmul
+else:
+	matmul_func = tf.batch_matmul
+
+class TransR(Model):
+	r'''
+	TransR first projects entities from entity space to corresponding relation space 
+	and then builds translations between projected entities. 
+	'''
+	def _transfer(self, transfer_matrix, embeddings):
+		return matmul_func(embeddings, transfer_matrix)
+
+	def _calc(self, h, t, r):
+		h = tf.nn.l2_normalize(h, -1)
+		t = tf.nn.l2_normalize(t, -1)
+		r = tf.nn.l2_normalize(r, -1)
+		return abs(h + r - t)
+
+	def embedding_def(self):
+		#Obtaining the initial configuration of the model
+		config = self.get_config()
+		#Defining required parameters of the model, including embeddings of entities and relations, and mapping matrices
+		self.ent_embeddings = tf.get_variable(name = "ent_embeddings", shape = [config.entTotal, config.ent_size], initializer = tf.contrib.layers.xavier_initializer(uniform = False))
+		self.rel_embeddings = tf.get_variable(name = "rel_embeddings", shape = [config.relTotal, config.rel_size], initializer = tf.contrib.layers.xavier_initializer(uniform = False))
+		self.transfer_matrix = tf.get_variable(name = "transfer_matrix", shape = [config.relTotal, config.ent_size * config.rel_size], initializer = tf.contrib.layers.xavier_initializer(uniform = False))
+		self.parameter_lists = {"ent_embeddings":self.ent_embeddings, \
+								"rel_embeddings":self.rel_embeddings, \
+								"transfer_matrix":self.transfer_matrix}
+
+	def loss_def(self):
+		#Obtaining the initial configuration of the model
+		config = self.get_config()
+		#To get positive triples and negative triples for training
+		#The shapes of pos_h, pos_t, pos_r are (batch_size, 1)
+		#The shapes of neg_h, neg_t, neg_r are (batch_size, negative_ent + negative_rel)
+		pos_h, pos_t, pos_r = self.get_positive_instance(in_batch = True)
+		neg_h, neg_t, neg_r = self.get_negative_instance(in_batch = True)
+		#Embedding entities and relations of triples, e.g. pos_h_e, pos_t_e and pos_r_e are embeddings for positive triples
+		pos_h_e = tf.nn.embedding_lookup(self.ent_embeddings, pos_h)
+		pos_t_e = tf.nn.embedding_lookup(self.ent_embeddings, pos_t)
+		pos_r_e = tf.nn.embedding_lookup(self.rel_embeddings, pos_r)
+		neg_h_e = tf.nn.embedding_lookup(self.ent_embeddings, neg_h)
+		neg_t_e = tf.nn.embedding_lookup(self.ent_embeddings, neg_t)
+		neg_r_e = tf.nn.embedding_lookup(self.rel_embeddings, neg_r)
+		#Getting the required mapping matrices
+		pos_matrix = tf.reshape(tf.nn.embedding_lookup(self.transfer_matrix, pos_r), [-1, config.ent_size, config.rel_size])
+		#Calculating score functions for all positive triples and negative triples
+		p_h = self._transfer(pos_matrix, pos_h_e)
+		p_t = self._transfer(pos_matrix, pos_t_e)
+		p_r = pos_r_e
+		if config.negative_rel == 0:
+			n_h = self._transfer(pos_matrix, neg_h_e)
+			n_t = self._transfer(pos_matrix, neg_t_e)
+			n_r = neg_r_e
+		else:
+			neg_matrix = tf.reshape(tf.nn.embedding_lookup(self.transfer_matrix, neg_r), [-1, config.ent_size, config.rel_size])
+			n_h = self._transfer(neg_matrix, neg_h_e)
+			n_t = self._transfer(neg_matrix, neg_t_e)
+			n_r = neg_r_e
+		#The shape of _p_score is (batch_size, 1, hidden_size)
+		#The shape of _n_score is (batch_size, negative_ent + negative_rel, hidden_size)
+		_p_score = self._calc(p_h, p_t, p_r)
+		_n_score = self._calc(n_h, n_t, n_r)
+		#The shape of p_score is (batch_size, 1, 1)
+		#The shape of n_score is (batch_size, negative_ent + negative_rel, 1)
+		p_score =  tf.reduce_sum(_p_score, -1, keep_dims = True)
+		n_score =  tf.reduce_sum(_n_score, -1, keep_dims = True)
+		#Calculating loss to get what the framework will optimize
+		self.loss = tf.reduce_mean(tf.maximum(p_score - n_score + config.margin, 0))
+
+	def predict_def(self):
+		config = self.get_config()
+		predict_h, predict_t, predict_r = self.get_predict_instance()
+		predict_h_e = tf.reshape(tf.nn.embedding_lookup(self.ent_embeddings, predict_h), [1, -1, config.ent_size])
+		predict_t_e = tf.reshape(tf.nn.embedding_lookup(self.ent_embeddings, predict_t), [1, -1, config.ent_size])
+		predict_r_e = tf.reshape(tf.nn.embedding_lookup(self.rel_embeddings, predict_r), [1, -1, config.rel_size])
+		predict_matrix = tf.reshape(tf.nn.embedding_lookup(self.transfer_matrix, predict_r[0]), [1, config.ent_size, config.rel_size])
+		h_e = tf.reshape(self._transfer(predict_matrix, predict_h_e), [-1, config.rel_size])
+		t_e = tf.reshape(self._transfer(predict_matrix, predict_t_e), [-1, config.rel_size])
+		r_e = predict_r_e
+		self.predict = tf.reduce_sum(self._calc(h_e, t_e, r_e), -1, keep_dims = True)
diff --git a/__pycache__/Config.cpython-36.pyc b/__pycache__/Config.cpython-36.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5955a9b6ef33f4dcab319e8f053f1f873315b029
GIT binary patch
literal 18420
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

literal 0
HcmV?d00001

diff --git a/__pycache__/Model.cpython-36.pyc b/__pycache__/Model.cpython-36.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e602c8f7ca80eb9a20effb0578449b4191b9be79
GIT binary patch
literal 3932
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
O`-FtX6ml+e&Hn(!H$Z>@

literal 0
HcmV?d00001

diff --git a/__pycache__/TransD.cpython-36.pyc b/__pycache__/TransD.cpython-36.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9bf4020ca80b1e2146e6592fbbda47c4532de897
GIT binary patch
literal 3675
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
QyH9AYzVgsTKeU4If0UN6>;M1&

literal 0
HcmV?d00001

diff --git a/__pycache__/TransE.cpython-36.pyc b/__pycache__/TransE.cpython-36.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7619340986a682f09847da6c5b75424b20ebd212
GIT binary patch
literal 2230
zcmaJ?OONC<5RUWi=RCA9E8q}7tkej05DOOsXeG2Dgcy)^Pc6X8#P06&CQf6g_c2PJ
zdarxt!XMx-`O0bd30&Z_)01ux!jT_erCcsoeW~0Vjr!?lAN@ESInM9SLG!V`kFGwz
zz#K*jXG-ksPCd+S;g|l@C(c(6^O*m_VLtb_-ZWt3p)(1tvCFxb5FLD5F<xW_-ZU4B
z`{>p*w`Qj<BQWbS?}an<na={u0Sj4#Ib<>GVUAcIrUyEFBvYXtT>a8d&{~k>DybJd
zndMT|NomeZ>MF@aEi1Opcv71^MOx>Tc>gk0oF%-x<c#HF{+_k-bdhHZvw_Q%<h4p9
zZ`D<jwzdyUsH9qP32S1WR3hP`&g-13yVg=>VrQC}J@hZo)h8HgXGxZBLzugDH)Mx!
zX&`rp5KADh_8QW7XHMhZcD6R67uN(9uKz-l0akXH_}Z;!+7&_%iw~)&WSJKE71v&R
zsqoTQyqIaS(4^Kx{^rOrcK&(qd{LGByjbV+{QPUi)9+=q<XNrGzguzf%>yd<Q~Gd~
z%E#wzbnmX7>wsoykqxk4#TXniw$IgYr($1c#z)gkjze^N^#vA<vvjr&E{y;%(vT%C
zxb){PaIg%Qk;(l_!u*$B<Ivb@1<>gIk5(TxWAr`?e|52Iz#Q-+y3k|fgLdgvUxJ3w
zTI4fCXX0sJq$SsZTBIwk2f0AzY|Nw{BjpGCCayez=kiqylcDa<c}=rQ%<{Q3SJOiy
zc#_IIy)3wnap<F}P76I)<cx7al}SW|9kt9aby%d&xm5b}S^6aBk{%pvkI^wsw+8Hi
z`Uvrdqo5-#a#bsM(>JGvI~PnQZ93(V5s$k2QpRV-Z)MaSH+JukJH#hfw|0s8hhmqo
zQ|KC6*@XRp#ZAI669&e<BtLi?FmvNWf)wr~!6w{9wYT(_0pww0m>nNr!|h&&qsFki
z-{G(cfCmRS1Ri!cY9infEXPgU^qT(G+l(z5G{a^DbOhaAGe)Vf<k=ise8i$1J^?o8
z4VvTT<hBDk4bL2gQ?~?^8ClB27mp@n8s~yurggTE=DP)FdXG6@QI?lV8d@KGbz^x3
z!SoeFfK{cypeGy&Rdp&d-iigEqdXjlEoWqeefoHxf}*M(uUC7X$z!9?m)sOBs@A0*
z?A9eug^tSfSzbaKmZ_ZQLi<If)a2AsLng+l01nYbJJszZrvcnCLNh^VCOP$1bfGcS
zW(6pqfdNne#&kthR!NQ(xNKL^jVRhlS^`=sS{BB}9Yes^;EH+!0|@A!l2iAXbdQh9
z;Q_f<M>|U1?CRKP!ql<xCjjIe<pT^PhJ&U&pny0_zaij<e}E1Df({3b;a><GLL2OB
zf+pO0hP@~^w$xY#_!l<ms1))ooHprAZ`s@;_IXx!som#Lz74g5w7p}X&0U1QhuJiV
z+V8cu!-#datoKVf9drtm?*R(f9!Sdn9qDctg8eZLZ@+ew<TlJ#r#F>*cLk_jOky2V
zYRVs_x=$&7lk38)hm`)jPK(`}h*DN%l-m2qH_gr7HN&|X_GPEby7chER7C4T?E54R
z<6iu_l}|z)h;@k{h$~jQUvr@<IV-BCZ7j`y!s`8(VI6<ky7;+KQ|5@6#AN9H4Q^9J
A0{{R3

literal 0
HcmV?d00001

diff --git a/__pycache__/TransH.cpython-36.pyc b/__pycache__/TransH.cpython-36.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9895449e7d56147e97f467f0d743646cac322064
GIT binary patch
literal 2815
zcmai0&5j#I5T5@T|L$h9$!;P*Mo0vsBumH*ArvJ7f+7~A?8ySPX5DRjobin59&eJ>
z_~cx}fio|_EA^FAUV#gI)nkvH2*HfHx~jUmx@+pI?z!LTG<z2x{rqU(vi`Jo9uNEj
zH1!z>x44~J1Kae@z(wz*-pm_#w)L&WUGBZIxF@`oJMg*v)av_hFv~ja+uHv==OP`F
zxOrSK575*XAi}sEINXL?hr6$=fycYt=fNu*&O#nR6YvIaq7QkCx6wzugGKgqa3<qS
zJ-+<4**MF4b19UN7ot~8L~j<)=Sen(GM@`sBt;@rFCX>p-8nruy>k!kv?oOx7fGI}
z+dViiu6juZb9gFLFRl%GF-Zkk&<waGr)F+1&oDH3Nwd;86L;ZiND<OQeSr1|O??Vd
zSW|oIln(b+&eADu$Zlzu&Y^{f5&dhI_+tyv1*dOp%s9h0jGhTG=gCaH`5TWUk9|)&
z#Yj6@rrYV~EX(CAPLoTan^N$_P%yQa^<C{Lk&d)2w4ME7$u1`Tb^m0N&%{Z(NXE&@
zcU;6j%6uw@g*y3RF0v<IvrIf^Pv^0Gc2a$kyYrX2!A$TYA=~hw2ppE(wJ-PACiU>y
z(5Epx)KmN>cFOcRcAGnhog%NkgiBvyEdfZ7+=9M|dt{Z)v9&UAI+e7fiF`}?o(xGF
z5ov&EH$GQ=U$%(1C)zHwEwwjF<FSdoB6~FIvtgVL0eVZ(bP9&v%l0N98Xi&t=yA~M
zJpKluw5Ha|LKKLB+oereoO)vivOf)`p~<DqJ>=73k+Je&(fALmrm+hC$Et;uBeW)3
zi-*6H|28MQM5nqdvVw`(x!@caRo?(Q;UY^$00&_qi)TXnY7)<dZY3E?!azpqE(&31
zp6*s~Vi$l#E>+)^M~GRzN928wen&UQqF}>38zp0t1l=aZMJ$u}JQX^^PR{ZoPIYUN
za4s^Y2%I5i6f!y2K^nglQt5*i@kJse+u4m-OGns}aj;!g?*Wtup@4mws6zFfD$~Jw
z9|Z566nE+`!MGS*$Dkq$%ZZ$iZF)Vtmxt?wzhzt}{wC}R$Ogm@0f$ZE(c2tQer^Bc
zE&<u42MwUG*7(a{85Zu;oBGfPB|$#gkqPvTS`JHseY2K>(udsIkpsx>S`Nz)a;KIf
zGrzkd)A$}%Zj@2k1;20jhT*T2&E<iSTjd_ct{T2=_`|ZZyau^h?w41}gO$6yZltT_
zVR;SG5!Psx*Li?Q0q*6ok&kdpSMm+Ww9ig?T;4dg0Osxyj<%JvvH{e+HBil&mSpTa
zE`}3R*+6Q84mn1roTRebDf4~#0TlWgA#9#2;PyfQF{+5Op{UfE7~?eFQEyKMy}wOu
zn&;0J^LNlJ=@gKJ580%3TI&;ZCgMzov-m|aTg-GYi{&`Uw3p^e^=}&F$y;RaV^3^S
zbw$-l?PEuzqz+2z<RCPbOjHa?wPGYO#(u+?Au|V>h-Ohm4kA(!r`<W6gA_!hb~6$)
z5;KSqn=>`cCF+o&@(dSlRN-3l?ui&tU{om|A}Dnm1eM|)*ayzOUBAS;ZM%)iG1SAM
z=|bmR?yc)+<E1Vkx-jYz+C4h~EPG{b%BOIqC>Q8_Q!M_DOvMt^a$vw7)^b%mbS6fn
zUq-NP7(Ot3vkXy44hn%l-6)%7YlT~8eb-v7WgzKS_X}_-X{*%@+pb`DXkZ6SB*UUc
z-4<T*4o!Ibe5?>fU^1}MA^s<5dcVB`o5os+%++kMWu<P_1`Ox*MgTOn0wJfp88HxX
zCs4VB9~Xn~=D7BPG(X1n)FFsvN4WVmDXx-xd9Y6B#yKY7Z|<z$0HhdQB#h}MW3!wu
zQsUc;{j!MD^+?DV&xefdl-4KoH69XqLS%bZ8;<T|Nq-A;p(}z+<au`FHG`-X-7+Kn
u0A;k8;b+9j=DJykOyzQv=Fh8K&=qa${>`<HzN~io6|JG@DvuC#+xZ91EYpSn

literal 0
HcmV?d00001

diff --git a/__pycache__/TransR.cpython-36.pyc b/__pycache__/TransR.cpython-36.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..90a96bc17354590c22f5b793e87497ee509c9ed5
GIT binary patch
literal 3115
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

literal 0
HcmV?d00001

diff --git a/__pycache__/distribute_training.cpython-36.pyc b/__pycache__/distribute_training.cpython-36.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..11404a037fc65a7986d6980ebf501973e987b490
GIT binary patch
literal 7691
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
GU;ckY@pw-F

literal 0
HcmV?d00001

diff --git a/base/Base.cpp b/base/Base.cpp
new file mode 100644
index 0000000..dd21094
--- /dev/null
+++ b/base/Base.cpp
@@ -0,0 +1,177 @@
+#include "Setting.h"
+#include "Random.h"
+#include "Reader.h"
+#include "Corrupt.h"
+#include "Test.h"
+#include "Valid.h"
+#include <cstdlib>
+#include <pthread.h>
+
+extern "C"
+void setInPath(char *path);
+
+extern "C"
+void setOutPath(char *path);
+
+extern "C"
+void setWorkThreads(INT threads);
+
+extern "C"
+void setBern(INT con);
+
+extern "C"
+INT getWorkThreads();
+
+extern "C"
+INT getEntityTotal();
+
+extern "C"
+INT getRelationTotal();
+
+extern "C"
+INT getTripleTotal();
+
+extern "C"
+INT getTrainTotal();
+
+extern "C"
+INT getTestTotal();
+
+extern "C"
+INT getValidTotal();
+
+//EDIT
+extern "C"
+INT getTrainTotal_();
+
+//EDIT
+extern "C"
+INT getBatchTotal();
+
+//EDIT
+extern "C"
+void setConstrainFlag(INT con);
+
+extern "C"
+void randReset();
+
+extern "C"
+void importTrainFiles();
+
+struct Parameter {
+	INT id;
+	INT *batch_h;
+	INT *batch_t;
+	INT *batch_r;
+	REAL *batch_y;
+	INT batchSize;
+	INT negRate;
+	INT negRelRate;
+};
+
+
+void* getBatch(void* con) {
+	Parameter *para = (Parameter *)(con);
+	INT id = para -> id;
+	INT *batch_h = para -> batch_h;
+	INT *batch_t = para -> batch_t;
+	INT *batch_r = para -> batch_r;
+	REAL *batch_y = para -> batch_y;
+	INT batchSize = para -> batchSize;
+	INT negRate = para -> negRate;
+	INT negRelRate = para -> negRelRate;
+	INT lef, rig;
+	if (batchSize % workThreads == 0) {
+		lef = id * (batchSize / workThreads);
+		rig = (id + 1) * (batchSize / workThreads);
+	} else {
+		lef = id * (batchSize / workThreads + 1);
+		rig = (id + 1) * (batchSize / workThreads + 1);
+		if (rig > batchSize) rig = batchSize;
+	}
+	REAL prob = 500;
+
+	for (INT batch = lef; batch < rig; batch++){
+		INT i;
+
+		/**
+		* EDIT
+		* select batch triple / train triple
+		**/
+		if (newBatchTotal > 0){
+            i = rand_max_range(id, trainTotal_ - newBatchTotal, trainTotal_);
+        }
+        else{
+            i = rand_max(id, trainTotal_);
+        }
+
+        //EDIT changed trainList to trainList_no
+		batch_h[batch] = trainList_no[i].h;
+        batch_t[batch] = trainList_no[i].t;
+        batch_r[batch] = trainList_no[i].r;
+		batch_y[batch] = 1;
+
+		INT last = batchSize;
+		for (INT times = 0; times < negRate; times ++) {
+            if (bernFlag)
+                prob = 1000 * right_mean[trainList_no[i].r] / (right_mean[trainList_no[i].r] + left_mean[trainList_no[i].r]);
+            if (randd(id) % 1000 < prob) {
+                batch_h[batch + last] = trainList_no[i].h;
+                batch_t[batch + last] = corrupt_head(id, trainList_no[i].h, trainList_no[i].r);
+                batch_r[batch + last] = trainList_no[i].r;
+            } else {
+                batch_h[batch + last] = corrupt_tail(id, trainList_no[i].t, trainList_no[i].r);;
+                batch_t[batch + last] = trainList_no[i].t;
+                batch_r[batch + last] = trainList_no[i].r;
+            }
+
+			batch_y[batch + last] = -1;
+			last += batchSize;
+
+		}
+
+
+		for (INT times = 0; times < negRelRate; times++) {
+			batch_h[batch + last] = trainList_no[i].h;
+			batch_t[batch + last] = trainList_no[i].t;
+			batch_r[batch + last] = corrupt_rel(id, trainList_no[i].h, trainList_no[i].t);
+			batch_y[batch + last] = -1;
+			last += batchSize;
+		}
+	}
+
+
+	pthread_exit(NULL);
+}
+
+
+
+extern "C"
+void sampling(INT *batch_h, INT *batch_t, INT *batch_r, REAL *batch_y, INT batchSize, INT negRate = 1, INT negRelRate = 0) {
+	pthread_t *pt = (pthread_t *)malloc(workThreads * sizeof(pthread_t));
+	Parameter *para = (Parameter *)malloc(workThreads * sizeof(Parameter));
+
+
+	for (INT threads = 0; threads < workThreads; threads++) {
+		para[threads].id = threads;
+		para[threads].batch_h = batch_h;
+		para[threads].batch_t = batch_t;
+		para[threads].batch_r = batch_r;
+		para[threads].batch_y = batch_y;
+		para[threads].batchSize = batchSize;
+		para[threads].negRate = negRate;
+		para[threads].negRelRate = negRelRate;
+		pthread_create(&pt[threads], NULL, getBatch, (void*)(para+threads));
+	}
+
+
+	for (INT threads = 0; threads < workThreads; threads++)
+		pthread_join(pt[threads], NULL);
+	free(pt);
+	free(para);
+}
+
+int main() {
+	importTrainFiles();
+	return 0;
+}
diff --git a/base/Corrupt.h b/base/Corrupt.h
new file mode 100644
index 0000000..41cbdf4
--- /dev/null
+++ b/base/Corrupt.h
@@ -0,0 +1,149 @@
+#ifndef CORRUPT_H
+#define CORRUPT_H
+#include "Random.h"
+#include "Triple.h"
+#include "Reader.h"
+
+INT corrupt_head(INT id, INT h, INT r) {
+	INT lef, rig, mid, ll, rr;
+	lef = lefHead[h] - 1;
+	rig = rigHead[h];
+	while (lef + 1 < rig) {
+		mid = (lef + rig) >> 1;
+		if (trainHead[mid].r >= r) rig = mid; else
+		lef = mid;
+	}
+	ll = rig;
+	lef = lefHead[h];
+	rig = rigHead[h] + 1;
+	while (lef + 1 < rig) {
+		mid = (lef + rig) >> 1;
+		if (trainHead[mid].r <= r) lef = mid; else
+		rig = mid;
+	}
+	rr = lef;
+	INT tmp = rand_max(id, entityTotal - (rr - ll + 1));
+	if (tmp < trainHead[ll].t) return tmp;
+	if (tmp > trainHead[rr].t - rr + ll - 1) return tmp + rr - ll + 1;
+	lef = ll, rig = rr + 1;
+	while (lef + 1 < rig) {
+		mid = (lef + rig) >> 1;
+		if (trainHead[mid].t - mid + ll - 1 < tmp)
+			lef = mid;
+		else 
+			rig = mid;
+	}
+	return tmp + lef - ll + 1;
+}
+
+INT corrupt_tail(INT id, INT t, INT r) {
+	INT lef, rig, mid, ll, rr;
+	lef = lefTail[t] - 1;
+	rig = rigTail[t];
+	while (lef + 1 < rig) {
+		mid = (lef + rig) >> 1;
+		if (trainTail[mid].r >= r) rig = mid; else
+		lef = mid;
+	}
+	ll = rig;
+	lef = lefTail[t];
+	rig = rigTail[t] + 1;
+	while (lef + 1 < rig) {
+		mid = (lef + rig) >> 1;
+		if (trainTail[mid].r <= r) lef = mid; else
+		rig = mid;
+	}
+	rr = lef;
+	INT tmp = rand_max(id, entityTotal - (rr - ll + 1));
+	if (tmp < trainTail[ll].h) return tmp;
+	if (tmp > trainTail[rr].h - rr + ll - 1) return tmp + rr - ll + 1;
+	lef = ll, rig = rr + 1;
+	while (lef + 1 < rig) {
+		mid = (lef + rig) >> 1;
+		if (trainTail[mid].h - mid + ll - 1 < tmp)
+			lef = mid;
+		else 
+			rig = mid;
+	}
+	return tmp + lef - ll + 1;
+}
+
+INT corrupt_rel(INT id, INT h, INT t) {
+	INT lef, rig, mid, ll, rr;
+	lef = lefRel[h] - 1;
+	rig = rigRel[h];
+	while (lef + 1 < rig) {
+		mid = (lef + rig) >> 1;
+		if (trainRel[mid].t >= t) rig = mid; else
+		lef = mid;
+	}
+	ll = rig;
+	lef = lefRel[h];
+	rig = rigRel[h] + 1;
+	while (lef + 1 < rig) {
+		mid = (lef + rig) >> 1;
+		if (trainRel[mid].t <= t) lef = mid; else
+		rig = mid;
+	}
+	rr = lef;
+	INT tmp = rand_max(id, relationTotal - (rr - ll + 1));
+	if (tmp < trainRel[ll].r) return tmp;
+	if (tmp > trainRel[rr].r - rr + ll - 1) return tmp + rr - ll + 1;
+	lef = ll, rig = rr + 1;
+	while (lef + 1 < rig) {
+		mid = (lef + rig) >> 1;
+		if (trainRel[mid].r - mid + ll - 1 < tmp)
+			lef = mid;
+		else 
+			rig = mid;
+	}
+	return tmp + lef - ll + 1;
+}
+
+
+bool _find(INT h, INT t, INT r) {
+    INT lef = 0;
+    INT rig = tripleTotal - 1;
+    INT mid;
+    while (lef + 1 < rig) {
+        INT mid = (lef + rig) >> 1;
+        if ((tripleList[mid]. h < h) || (tripleList[mid]. h == h && tripleList[mid]. r < r) || (tripleList[mid]. h == h && tripleList[mid]. r == r && tripleList[mid]. t < t)) lef = mid; else rig = mid;
+    }
+    if (tripleList[lef].h == h && tripleList[lef].r == r && tripleList[lef].t == t) return true;
+    if (tripleList[rig].h == h && tripleList[rig].r == r && tripleList[rig].t == t) return true;
+    return false;
+}
+
+
+INT corrupt(INT h, INT r){
+	INT ll = tail_lef[r];
+	INT rr = tail_rig[r];
+	INT t;
+
+    //EDIT
+//	while (ll < rr){
+//	    t = tail_type[ll];
+//	    if (not _find(h, t, r)) {
+//	        return t;
+//	    }
+//	    ll++;
+//	}
+//	return corrupt_head(0, h, r);
+
+    INT loop = 0;
+	while(1) {
+		t = tail_type[rand(ll, rr)];
+		if (not _find(h, t, r)) {
+		//	printf("r:%ld\tt:%ld\n", r, t);
+			return t;
+		} else {
+			loop ++;
+			if (loop >= 1000){
+			//	printf("drop\n");
+				return corrupt_head(0, h, r);
+			}
+		}
+	}
+}
+
+#endif
diff --git a/base/Random.h b/base/Random.h
new file mode 100644
index 0000000..f9c968d
--- /dev/null
+++ b/base/Random.h
@@ -0,0 +1,41 @@
+#ifndef RANDOM_H
+#define RANDOM_H
+#include "Setting.h"
+#include <cstdlib>
+
+unsigned long long *next_random;
+
+extern "C"
+void randReset() {
+	next_random = (unsigned long long *)calloc(workThreads, sizeof(unsigned long long));
+	for (INT i = 0; i < workThreads; i++)
+		next_random[i] = rand();
+}
+
+
+unsigned long long randd(INT id) {
+	next_random[id] = next_random[id] * (unsigned long long)25214903917 + 11;
+	return next_random[id];
+}
+
+
+INT rand_max(INT id, INT x) {
+	INT res = randd(id) % x;
+	while (res < 0)
+		res += x;
+	return res;
+}
+
+
+
+//[a,b)
+INT rand_max_range(INT id, INT a, INT b){
+    return (randd(id) % (b-a))+ a;
+}
+
+
+//[a,b)
+INT rand(INT a, INT b){
+	return (rand() % (b-a))+ a;
+}
+#endif
diff --git a/base/Reader.h b/base/Reader.h
new file mode 100644
index 0000000..b3b1f3a
--- /dev/null
+++ b/base/Reader.h
@@ -0,0 +1,365 @@
+#ifndef READER_H
+#define READER_H
+#include "Setting.h"
+#include "Triple.h"
+#include <cstdlib>
+#include <algorithm>
+#include <iostream>
+
+INT *freqRel, *freqEnt;
+INT *lefHead, *rigHead;
+INT *lefTail, *rigTail;
+INT *lefRel, *rigRel;
+REAL *left_mean, *right_mean;
+
+Triple *trainList;
+Triple *trainHead;
+Triple *trainTail;
+Triple *trainRel;
+
+
+//EDIT
+Triple *trainList_no;   //data structure containing training triples not ordered
+
+
+INT *testLef, *testRig;
+INT *validLef, *validRig;
+
+extern "C"
+void importTrainFiles() {
+
+	printf("The toolkit is importing datasets.\n");
+	FILE *fin;
+	FILE *fin_; //EDIT
+	int tmp;
+
+    //read relations
+	fin = fopen((inPath + "relation2id.txt").c_str(), "r");
+	if (fin == nullptr) {
+		std::cout << '`' << inPath << "relation2id.txt" << '`' << " does not exist" << std::endl;
+		return;
+	}
+	tmp = fscanf(fin, "%ld", &relationTotal);
+	printf("The total of relations is %ld.\n", relationTotal);
+	fclose(fin);
+
+
+    //read entities
+	fin = fopen((inPath + "entity2id.txt").c_str(), "r");
+	if (fin == nullptr) {
+		std::cout << '`' << inPath << "entity2id.txt" << '`' << " does not exist" << std::endl;
+		return;
+	}
+	tmp = fscanf(fin, "%ld", &entityTotal);
+    printf("The total of entities is %ld.\n", entityTotal);
+    fclose(fin);
+
+
+	/**
+    * EDIT
+    * check if new batch file exists
+    * if it exists get only new batch size
+    **/
+    fin_ = fopen((inPath + "batch2id.txt").c_str(), "r");
+    if (fin_ != nullptr){
+        std::cout << '`' << inPath << "batch2id.txt" << '`' << " founded!" << std::endl;
+        tmp = fscanf(fin_, "%ld", &newBatchTotal);
+        std::cout << "The total number of new batch triples is: " << newBatchTotal << std::endl;
+        fclose(fin_);
+    }
+
+
+    //read training triples
+	fin = fopen((inPath + "train2id.txt").c_str(), "r");
+	if (fin == nullptr) {
+		std::cout << '`' << inPath << "train2id.txt" << '`' << " does not exist" << std::endl;
+		return;
+	}
+	tmp = fscanf(fin, "%ld", &trainTotal);
+	trainTotal_ = trainTotal;           //traingTotal_ contains # training triples counting duplicates, too
+	printf("The total of train triples is %ld.\n", trainTotal);
+
+
+    //data structres ordered by . . .
+	trainList = (Triple *)calloc(trainTotal, sizeof(Triple));
+	trainHead = (Triple *)calloc(trainTotal, sizeof(Triple));
+	trainTail = (Triple *)calloc(trainTotal, sizeof(Triple));
+	trainRel = (Triple *)calloc(trainTotal, sizeof(Triple));
+	freqRel = (INT *)calloc(relationTotal, sizeof(INT));
+	freqEnt = (INT *)calloc(entityTotal, sizeof(INT));
+	//EDIT
+    trainList_no = (Triple *)calloc(trainTotal, sizeof(Triple));    //not ordered
+
+	for (INT i = 0; i < trainTotal; i++) {
+		tmp = fscanf(fin, "%ld", &trainList[i].h);
+		tmp = fscanf(fin, "%ld", &trainList[i].t);
+		tmp = fscanf(fin, "%ld", &trainList[i].r);
+
+		//EDIT
+        trainList_no[i].h = trainList[i].h;
+        trainList_no[i].t = trainList[i].t;
+        trainList_no[i].r = trainList[i].r;
+	}
+	fclose(fin);
+	std::sort(trainList, trainList + trainTotal, Triple::cmp_head);
+
+	tmp = trainTotal;
+	trainTotal = 1;
+	trainHead[0] = trainTail[0] = trainRel[0] = trainList[0];
+	freqEnt[trainList[0].t] += 1;
+	freqEnt[trainList[0].h] += 1;
+	freqRel[trainList[0].r] += 1;
+	for (INT i = 1; i < tmp; i++)
+		if (trainList[i].h != trainList[i - 1].h ||
+		    trainList[i].r != trainList[i - 1].r ||
+		    trainList[i].t != trainList[i - 1].t) {
+			trainHead[trainTotal] = trainTail[trainTotal] = trainRel[trainTotal] =
+			    trainList[trainTotal] = trainList[i];
+			trainTotal++;
+			freqEnt[trainList[i].t]++;
+			freqEnt[trainList[i].h]++;
+			freqRel[trainList[i].r]++;
+		}
+
+	std::sort(trainHead, trainHead + trainTotal, Triple::cmp_head);
+	std::sort(trainTail, trainTail + trainTotal, Triple::cmp_tail);
+	std::sort(trainRel, trainRel + trainTotal, Triple::cmp_rel);
+
+
+	lefHead = (INT *)calloc(entityTotal, sizeof(INT));
+	rigHead = (INT *)calloc(entityTotal, sizeof(INT));
+	lefTail = (INT *)calloc(entityTotal, sizeof(INT));
+	rigTail = (INT *)calloc(entityTotal, sizeof(INT));
+	lefRel = (INT *)calloc(entityTotal, sizeof(INT));
+	rigRel = (INT *)calloc(entityTotal, sizeof(INT));
+	memset(rigHead, -1, sizeof(INT) * entityTotal);
+	memset(rigTail, -1, sizeof(INT) * entityTotal);
+	memset(rigRel, -1, sizeof(INT) * entityTotal);
+	for (INT i = 1; i < trainTotal; i++) {
+		if (trainTail[i].t != trainTail[i - 1].t) {
+			rigTail[trainTail[i - 1].t] = i - 1;
+			lefTail[trainTail[i].t] = i;
+		}
+		if (trainHead[i].h != trainHead[i - 1].h) {
+			rigHead[trainHead[i - 1].h] = i - 1;
+			lefHead[trainHead[i].h] = i;
+		}
+		if (trainRel[i].h != trainRel[i - 1].h) {
+			rigRel[trainRel[i - 1].h] = i - 1;
+			lefRel[trainRel[i].h] = i;
+		}
+	}
+	lefHead[trainHead[0].h] = 0;
+	rigHead[trainHead[trainTotal - 1].h] = trainTotal - 1;
+	lefTail[trainTail[0].t] = 0;
+	rigTail[trainTail[trainTotal - 1].t] = trainTotal - 1;
+	lefRel[trainRel[0].h] = 0;
+	rigRel[trainRel[trainTotal - 1].h] = trainTotal - 1;
+
+	left_mean = (REAL *)calloc(relationTotal, sizeof(REAL));
+	right_mean = (REAL *)calloc(relationTotal, sizeof(REAL));
+	for (INT i = 0; i < entityTotal; i++) {
+		for (INT j = lefHead[i] + 1; j <= rigHead[i]; j++)
+			if (trainHead[j].r != trainHead[j - 1].r)
+				left_mean[trainHead[j].r] += 1.0;
+		if (lefHead[i] <= rigHead[i])
+			left_mean[trainHead[lefHead[i]].r] += 1.0;
+		for (INT j = lefTail[i] + 1; j <= rigTail[i]; j++)
+			if (trainTail[j].r != trainTail[j - 1].r)
+				right_mean[trainTail[j].r] += 1.0;
+		if (lefTail[i] <= rigTail[i])
+			right_mean[trainTail[lefTail[i]].r] += 1.0;
+	}
+	for (INT i = 0; i < relationTotal; i++) {
+		left_mean[i] = freqRel[i] / left_mean[i];
+		right_mean[i] = freqRel[i] / right_mean[i];
+	}
+}
+
+Triple *testList;
+Triple *validList;
+Triple *tripleList;
+
+extern "C"
+void importTestFiles() {
+	FILE *fin;
+	INT tmp;
+
+	fin = fopen((inPath + "relation2id.txt").c_str(), "r");
+	if (fin == nullptr) {
+		std::cout << '`' << inPath << "relation2id.txt" << '`' << " does not exist" << std::endl;
+		return;
+	}
+	tmp = fscanf(fin, "%ld", &relationTotal);
+	fclose(fin);
+
+
+	fin = fopen((inPath + "entity2id.txt").c_str(), "r");
+	if (fin == nullptr) {
+		std::cout << '`' << inPath << "entity2id.txt" << '`' << " does not exist" << std::endl;
+		return;
+	}
+	tmp = fscanf(fin, "%ld", &entityTotal);
+	fclose(fin);
+
+
+	FILE *f_kb1 = fopen((inPath + "test2id.txt").c_str(), "r");
+	if (f_kb1 == nullptr) {
+		std::cout << '`' << inPath << "test2id.txt" << '`' << " does not exist" << std::endl;
+		return;
+	}
+
+	FILE *f_kb2 = fopen((inPath + "train2id.txt").c_str(), "r");
+	if (f_kb2 == nullptr) {
+		std::cout << '`' << inPath << "train2id.txt" << '`' << " does not exist" << std::endl;
+		return;
+	}
+
+	FILE *f_kb3 = fopen((inPath + "valid2id.txt").c_str(), "r");
+	if (f_kb3 == nullptr) {
+		std::cout << '`' << inPath << "valid2id.txt" << '`' << " does not exist" << std::endl;
+		return;
+	}
+
+	tmp = fscanf(f_kb1, "%ld", &testTotal);
+	tmp = fscanf(f_kb2, "%ld", &trainTotal);
+	tmp = fscanf(f_kb3, "%ld", &validTotal);
+	tripleTotal = testTotal + trainTotal + validTotal;
+
+	testList = (Triple *)calloc(testTotal, sizeof(Triple));
+	validList = (Triple *)calloc(validTotal, sizeof(Triple));
+	tripleList = (Triple *)calloc(tripleTotal, sizeof(Triple));
+
+	for (INT i = 0; i < testTotal; i++) {
+		tmp = fscanf(f_kb1, "%ld", &testList[i].h);
+		tmp = fscanf(f_kb1, "%ld", &testList[i].t);
+		tmp = fscanf(f_kb1, "%ld", &testList[i].r);
+		tripleList[i] = testList[i];
+	}
+
+	for (INT i = 0; i < trainTotal; i++) {
+		tmp = fscanf(f_kb2, "%ld", &tripleList[i + testTotal].h);
+		tmp = fscanf(f_kb2, "%ld", &tripleList[i + testTotal].t);
+		tmp = fscanf(f_kb2, "%ld", &tripleList[i + testTotal].r);
+	}
+
+	for (INT i = 0; i < validTotal; i++) {
+		tmp = fscanf(f_kb3, "%ld", &tripleList[i + testTotal + trainTotal].h);
+		tmp = fscanf(f_kb3, "%ld", &tripleList[i + testTotal + trainTotal].t);
+		tmp = fscanf(f_kb3, "%ld", &tripleList[i + testTotal + trainTotal].r);
+		validList[i] = tripleList[i + testTotal + trainTotal];
+	}
+
+	fclose(f_kb1);
+	fclose(f_kb2);
+	fclose(f_kb3);
+
+	std::sort(tripleList, tripleList + tripleTotal, Triple::cmp_head);
+	std::sort(testList, testList + testTotal, Triple::cmp_rel2);
+	std::sort(validList, validList + validTotal, Triple::cmp_rel2);
+
+	printf("The total of test triples is %ld.\n", testTotal);
+	printf("The total of valid triples is %ld.\n", validTotal);
+
+
+	testLef = (INT *)calloc(relationTotal, sizeof(INT));
+	testRig = (INT *)calloc(relationTotal, sizeof(INT));
+	memset(testLef, -1, sizeof(INT) * relationTotal);
+	memset(testRig, -1, sizeof(INT) * relationTotal);
+	for (INT i = 1; i < testTotal; i++) {
+		if (testList[i].r != testList[i - 1].r) {
+			testRig[testList[i - 1].r] = i - 1;
+			testLef[testList[i].r] = i;
+		}
+	}
+	testLef[testList[0].r] = 0;
+	testRig[testList[testTotal - 1].r] = testTotal - 1;
+
+	validLef = (INT *)calloc(relationTotal, sizeof(INT));
+	validRig = (INT *)calloc(relationTotal, sizeof(INT));
+	memset(validLef, -1, sizeof(INT) * relationTotal);
+	memset(validRig, -1, sizeof(INT) * relationTotal);
+	for (INT i = 1; i < validTotal; i++) {
+		if (validList[i].r != validList[i - 1].r) {
+			validRig[validList[i - 1].r] = i - 1;
+			validLef[validList[i].r] = i;
+		}
+	}
+	validLef[validList[0].r] = 0;
+	validRig[validList[validTotal - 1].r] = validTotal - 1;
+}
+
+INT *head_lef;
+INT *head_rig;
+INT *tail_lef;
+INT *tail_rig;
+INT *head_type;
+INT *tail_type;
+
+extern "C"
+void importTypeFiles() {
+	head_lef = (INT *)calloc(relationTotal, sizeof(INT));
+	head_rig = (INT *)calloc(relationTotal, sizeof(INT));
+	tail_lef = (INT *)calloc(relationTotal, sizeof(INT));
+	tail_rig = (INT *)calloc(relationTotal, sizeof(INT));
+	INT total_lef = 0;
+	INT total_rig = 0;
+
+	FILE *f_type = fopen((inPath + "type_constrain.txt").c_str(), "r");
+	if (f_type == nullptr) {
+		std::cout << '`' << inPath << "type_constrain.txt" << '`' << " does not exist" << std::endl;
+		return;
+	}
+
+	INT tmp;
+	tmp = fscanf(f_type, "%ld", &tmp);
+	for (INT i = 0; i < relationTotal; i++) {
+		INT rel, tot;
+		tmp = fscanf(f_type, "%ld %ld", &rel, &tot);
+		for (INT j = 0; j < tot; j++) {
+			tmp = fscanf(f_type, "%ld", &tmp);
+			total_lef++;
+		}
+		tmp = fscanf(f_type, "%ld%ld", &rel, &tot);
+		for (INT j = 0; j < tot; j++) {
+			tmp = fscanf(f_type, "%ld", &tmp);
+			total_rig++;
+		}
+	}
+	fclose(f_type);
+
+	head_type = (INT *)calloc(total_lef, sizeof(INT));
+	tail_type = (INT *)calloc(total_rig, sizeof(INT));
+	total_lef = 0;
+	total_rig = 0;
+	f_type = fopen((inPath + "type_constrain.txt").c_str(), "r");
+
+	if (f_type == nullptr) {
+		std::cout << '`' << inPath << "type_constrain.txt" << '`' << " does not exist" << std::endl;
+		return;
+	}
+
+	tmp = fscanf(f_type, "%ld", &tmp);
+	for (INT i = 0; i < relationTotal; i++) {
+		INT rel, tot;
+		tmp = fscanf(f_type, "%ld%ld", &rel, &tot);
+		head_lef[rel] = total_lef;
+		for (INT j = 0; j < tot; j++) {
+			tmp = fscanf(f_type, "%ld", &head_type[total_lef]);
+			total_lef++;
+		}
+		head_rig[rel] = total_lef;
+		std::sort(head_type + head_lef[rel], head_type + head_rig[rel]);
+		tmp = fscanf(f_type, "%ld%ld", &rel, &tot);
+		tail_lef[rel] = total_rig;
+		for (INT j = 0; j < tot; j++) {
+			tmp = fscanf(f_type, "%ld", &tail_type[total_rig]);
+			total_rig++;
+		}
+		tail_rig[rel] = total_rig;
+		std::sort(tail_type + tail_lef[rel], tail_type + tail_rig[rel]);
+	}
+	fclose(f_type);
+}
+
+#endif
diff --git a/base/Setting.h b/base/Setting.h
new file mode 100644
index 0000000..012e500
--- /dev/null
+++ b/base/Setting.h
@@ -0,0 +1,127 @@
+#ifndef SETTING_H
+#define SETTING_H
+#define INT long
+#define REAL float
+#include <cstring>
+#include <cstdio>
+#include <string>
+
+std::string inPath = "../data/FB15K/";
+std::string outPath = "../data/FB15K/";
+
+extern "C"
+void setInPath(char *path) {
+	INT len = strlen(path);
+	inPath = "";
+	for (INT i = 0; i < len; i++)
+		inPath = inPath + path[i];
+	printf("Input Files Path : %s\n", inPath.c_str());
+}
+
+extern "C"
+void setOutPath(char *path) {
+	INT len = strlen(path);
+	outPath = "";
+	for (INT i = 0; i < len; i++)
+		outPath = outPath + path[i];
+	printf("Output Files Path : %s\n", outPath.c_str());
+}
+
+/*
+============================================================
+*/
+
+INT workThreads = 1;
+
+extern "C"
+void setWorkThreads(INT threads) {
+	workThreads = threads;
+}
+
+extern "C"
+INT getWorkThreads() {
+	return workThreads;
+}
+
+/*
+============================================================
+*/
+
+INT relationTotal = 0;
+INT entityTotal = 0;
+INT tripleTotal = 0;
+INT testTotal = 0;
+INT trainTotal = 0;
+
+//EDIT
+//training triples with duplicates
+INT trainTotal_ = 0;
+
+INT validTotal = 0;
+
+//EDIT
+INT newBatchTotal = 0;
+
+extern "C"
+INT getEntityTotal() {
+	return entityTotal;
+}
+
+extern "C"
+INT getRelationTotal() {
+	return relationTotal;
+}
+
+extern "C"
+INT getTripleTotal() {
+	return tripleTotal;
+}
+
+extern "C"
+INT getTrainTotal() {
+	return trainTotal;
+}
+
+//EDIT
+extern "C"
+INT getTrainTotal_() {
+	return trainTotal_;
+}
+
+//EDIT
+extern "C"
+INT getBatchTotal() {
+    return newBatchTotal;
+}
+
+extern "C"
+INT getTestTotal() {
+	return testTotal;
+}
+
+extern "C"
+INT getValidTotal() {
+	return validTotal;
+}
+/*
+============================================================
+*/
+
+INT bernFlag = 0;
+//EDIT
+INT constrainFlag = 0;
+
+extern "C"
+void setBern(INT con) {
+	bernFlag = con;
+}
+
+//EDIT
+extern "C"
+void setConstrainFlag(INT con) {
+	constrainFlag = con;
+}
+
+
+
+#endif
diff --git a/base/Test.h b/base/Test.h
new file mode 100644
index 0000000..5de05a2
--- /dev/null
+++ b/base/Test.h
@@ -0,0 +1,411 @@
+#ifndef TEST_H
+#define TEST_H
+#include "Setting.h"
+#include "Reader.h"
+#include "Corrupt.h"
+
+/*=====================================================================================
+link prediction
+======================================================================================*/
+INT lastHead = 0;
+INT lastTail = 0;
+REAL l1_filter_tot = 0, l1_tot = 0, r1_tot = 0, r1_filter_tot = 0, l_tot = 0, r_tot = 0, l_filter_rank = 0, l_rank = 0, l_filter_reci_rank = 0, l_reci_rank = 0;
+REAL l3_filter_tot = 0, l3_tot = 0, r3_tot = 0, r3_filter_tot = 0, l_filter_tot = 0, r_filter_tot = 0, r_filter_rank = 0, r_rank = 0, r_filter_reci_rank = 0, r_reci_rank = 0;
+
+//TYPE_C
+REAL l1_filter_tot_constrain = 0, l1_tot_constrain = 0, r1_tot_constrain = 0, r1_filter_tot_constrain = 0, l_tot_constrain = 0, r_tot_constrain = 0, l_filter_rank_constrain = 0, l_rank_constrain = 0, l_filter_reci_rank_constrain = 0, l_reci_rank_constrain = 0;
+REAL l3_filter_tot_constrain = 0, l3_tot_constrain = 0, r3_tot_constrain = 0, r3_filter_tot_constrain = 0, l_filter_tot_constrain = 0, r_filter_tot_constrain = 0, r_filter_rank_constrain = 0, r_rank_constrain = 0, r_filter_reci_rank_constrain = 0, r_reci_rank_constrain = 0;
+
+extern "C"
+void initTest() {
+    lastHead = 0;
+    lastTail = 0;
+
+    l1_filter_tot = 0, l1_tot = 0, r1_tot = 0, r1_filter_tot = 0, l_tot = 0, r_tot = 0, l_filter_rank = 0, l_rank = 0, l_filter_reci_rank = 0, l_reci_rank = 0;
+    l3_filter_tot = 0, l3_tot = 0, r3_tot = 0, r3_filter_tot = 0, l_filter_tot = 0, r_filter_tot = 0, r_filter_rank = 0, r_rank = 0, r_filter_reci_rank = 0, r_reci_rank = 0;
+
+    //TYPE_C
+    l1_filter_tot_constrain = 0, l1_tot_constrain = 0, r1_tot_constrain = 0, r1_filter_tot_constrain = 0, l_tot_constrain = 0, r_tot_constrain = 0, l_filter_rank_constrain = 0, l_rank_constrain = 0, l_filter_reci_rank_constrain = 0, l_reci_rank_constrain = 0;
+    l3_filter_tot_constrain = 0, l3_tot_constrain = 0, r3_tot_constrain = 0, r3_filter_tot_constrain = 0, l_filter_tot_constrain = 0, r_filter_tot_constrain = 0, r_filter_rank_constrain = 0, r_rank_constrain = 0, r_filter_reci_rank_constrain = 0, r_reci_rank_constrain = 0;
+}
+
+
+extern "C"
+void getHeadBatch(INT *ph, INT *pt, INT *pr) {
+    for (INT i = 0; i < entityTotal; i++) {
+        ph[i] = i;
+        pt[i] = testList[lastHead].t;
+        pr[i] = testList[lastHead].r;
+    }
+}
+
+extern "C"
+void getTailBatch(INT *ph, INT *pt, INT *pr) {
+    for (INT i = 0; i < entityTotal; i++) {
+        ph[i] = testList[lastTail].h;
+        pt[i] = i;
+        pr[i] = testList[lastTail].r;
+    }
+}
+
+extern "C"
+void testHead(REAL *con) {
+    INT h = testList[lastHead].h;
+    INT t = testList[lastHead].t;
+    INT r = testList[lastHead].r;
+    REAL minimal = con[h];
+    INT l_s = 0;
+    INT l_filter_s = 0;
+
+
+    //TYPE_C
+    INT l_s_constrain = 0;
+    INT l_filter_s_constrain = 0;
+    INT lef = 0;
+    INT rig = 0;
+    if (constrainFlag != 0){
+        lef = head_lef[r];
+        rig = head_rig[r];
+    }
+
+    for (INT j = 0; j < entityTotal; j++) {
+        if (j != h) {
+
+            REAL value = con[j];
+            if (value < minimal) {
+                l_s += 1;
+                if (not _find(j, t, r))
+                    l_filter_s += 1;
+            }
+
+            //TYPE_C
+            if (constrainFlag != 0){
+                while (lef < rig && head_type[lef] < j) lef ++;
+                if (lef < rig && j == head_type[lef]) {
+                    if (value < minimal) {
+                        l_s_constrain += 1;
+                        if (not _find(j, t, r)) {
+                            l_filter_s_constrain += 1;
+                        }
+                    }
+                }
+            }
+
+        }
+    }
+
+    if (l_filter_s < 10) l_filter_tot += 1;
+    if (l_s < 10) l_tot += 1;
+    if (l_filter_s < 3) l3_filter_tot += 1;
+    if (l_s < 3) l3_tot += 1;
+    if (l_filter_s < 1) l1_filter_tot += 1;
+    if (l_s < 1) l1_tot += 1;
+
+    //TYPE_C
+    if (constrainFlag != 0){
+        if (l_filter_s_constrain < 10) l_filter_tot_constrain += 1;
+        if (l_s_constrain < 10) l_tot_constrain += 1;
+        if (l_filter_s_constrain < 3) l3_filter_tot_constrain += 1;
+        if (l_s_constrain < 3) l3_tot_constrain += 1;
+        if (l_filter_s_constrain < 1) l1_filter_tot_constrain += 1;
+        if (l_s_constrain < 1) l1_tot_constrain += 1;
+    }
+
+    l_filter_rank += (l_filter_s+1);
+    l_rank += (1+l_s);
+    l_filter_reci_rank += 1.0/(l_filter_s+1);
+    l_reci_rank += 1.0/(l_s+1);
+
+    //TYPE_C
+    if (constrainFlag != 0){
+        l_filter_rank_constrain += (l_filter_s_constrain+1);
+        l_rank_constrain += (1+l_s_constrain);
+        l_filter_reci_rank_constrain += 1.0/(l_filter_s_constrain+1);
+        l_reci_rank_constrain += 1.0/(l_s_constrain+1);
+    }
+
+    lastHead++;
+}
+
+extern "C"
+void testTail(REAL *con) {
+    INT h = testList[lastTail].h;
+    INT t = testList[lastTail].t;
+    INT r = testList[lastTail].r;
+    REAL minimal = con[t];
+    INT r_s = 0;
+    INT r_filter_s = 0;
+
+    //TYPE_C
+    INT r_s_constrain = 0;
+    INT r_filter_s_constrain = 0;
+    INT lef = 0;
+    INT rig = 0;
+    if (constrainFlag != 0){
+        lef = tail_lef[r];
+        rig = tail_rig[r];
+    }
+
+    for (INT j = 0; j < entityTotal; j++) {
+        if (j != t) {
+
+            REAL value = con[j];
+            if (value < minimal) {
+                r_s += 1;
+                if (not _find(h, j, r))
+                    r_filter_s += 1;
+            }
+
+            //TYPE_C
+            if (constrainFlag != 0){
+                while (lef < rig && tail_type[lef] < j) lef ++;
+                if (lef < rig && j == tail_type[lef]) {
+                        if (value < minimal) {
+                            r_s_constrain += 1;
+                            if (not _find(h, j ,r)) {
+                                r_filter_s_constrain += 1;
+                            }
+                        }
+                }
+            }
+
+        }
+    }
+
+    if (r_filter_s < 10) r_filter_tot += 1;
+    if (r_s < 10) r_tot += 1;
+    if (r_filter_s < 3) r3_filter_tot += 1;
+    if (r_s < 3) r3_tot += 1;
+    if (r_filter_s < 1) r1_filter_tot += 1;
+    if (r_s < 1) r1_tot += 1;
+
+    //TYPE_C
+    if (constrainFlag != 0){
+        if (r_filter_s_constrain < 10) r_filter_tot_constrain += 1;
+        if (r_s_constrain < 10) r_tot_constrain += 1;
+        if (r_filter_s_constrain < 3) r3_filter_tot_constrain += 1;
+        if (r_s_constrain < 3) r3_tot_constrain += 1;
+        if (r_filter_s_constrain < 1) r1_filter_tot_constrain += 1;
+        if (r_s_constrain < 1) r1_tot_constrain += 1;
+    }
+
+    r_filter_rank += (1+r_filter_s);
+    r_rank += (1+r_s);
+    r_filter_reci_rank += 1.0/(1+r_filter_s);
+    r_reci_rank += 1.0/(1+r_s);
+
+    //TYPE_C
+    if (constrainFlag != 0){
+        r_filter_rank_constrain += (1+r_filter_s_constrain);
+        r_rank_constrain += (1+r_s_constrain);
+        r_filter_reci_rank_constrain += 1.0/(1+r_filter_s_constrain);
+        r_reci_rank_constrain += 1.0/(1+r_s_constrain);
+    }
+
+    lastTail++;
+}
+
+extern "C"
+void test_link_prediction() {
+    l_rank /= testTotal;
+    r_rank /= testTotal;
+    l_reci_rank /= testTotal;
+    r_reci_rank /= testTotal;
+ 
+    l_tot /= testTotal;
+    l3_tot /= testTotal;
+    l1_tot /= testTotal;
+ 
+    r_tot /= testTotal;
+    r3_tot /= testTotal;
+    r1_tot /= testTotal;
+
+    // with filter
+    l_filter_rank /= testTotal;
+    r_filter_rank /= testTotal;
+    l_filter_reci_rank /= testTotal;
+    r_filter_reci_rank /= testTotal;
+
+    l_filter_tot /= testTotal;
+    l3_filter_tot /= testTotal;
+    l1_filter_tot /= testTotal;
+
+    r_filter_tot /= testTotal;
+    r3_filter_tot /= testTotal;
+    r1_filter_tot /= testTotal;
+
+    printf("no type constraint results:\n");
+    
+    printf("metric:\t\t\t MRR \t\t MR \t\t hit@10 \t hit@3  \t hit@1 \n");
+    printf("l(raw):\t\t\t %f \t %f \t %f \t %f \t %f \n", l_reci_rank, l_rank, l_tot, l3_tot, l1_tot);
+    printf("r(raw):\t\t\t %f \t %f \t %f \t %f \t %f \n", r_reci_rank, r_rank, r_tot, r3_tot, r1_tot);
+    printf("averaged(raw):\t\t %f \t %f \t %f \t %f \t %f \n",
+            (l_reci_rank+r_reci_rank)/2, (l_rank+r_rank)/2, (l_tot+r_tot)/2, (l3_tot+r3_tot)/2, (l1_tot+r1_tot)/2);
+    printf("\n");
+    printf("l(filter):\t\t %f \t %f \t %f \t %f \t %f \n", l_filter_reci_rank, l_filter_rank, l_filter_tot, l3_filter_tot, l1_filter_tot);
+    printf("r(filter):\t\t %f \t %f \t %f \t %f \t %f \n", r_filter_reci_rank, r_filter_rank, r_filter_tot, r3_filter_tot, r1_filter_tot);
+    printf("averaged(filter):\t %f \t %f \t %f \t %f \t %f \n",
+            (l_filter_reci_rank+r_filter_reci_rank)/2, (l_filter_rank+r_filter_rank)/2, (l_filter_tot+r_filter_tot)/2, (l3_filter_tot+r3_filter_tot)/2, (l1_filter_tot+r1_filter_tot)/2);
+
+    //TYPE_C
+    if (constrainFlag != 0){
+        l_rank_constrain /= testTotal;
+        r_rank_constrain /= testTotal;
+        l_reci_rank_constrain /= testTotal;
+        r_reci_rank_constrain /= testTotal;
+
+        l_tot_constrain /= testTotal;
+        l3_tot_constrain /= testTotal;
+        l1_tot_constrain /= testTotal;
+
+        r_tot_constrain /= testTotal;
+        r3_tot_constrain /= testTotal;
+        r1_tot_constrain /= testTotal;
+
+        //TYPE_C with filter
+        l_filter_rank_constrain /= testTotal;
+        r_filter_rank_constrain /= testTotal;
+        l_filter_reci_rank_constrain /= testTotal;
+        r_filter_reci_rank_constrain /= testTotal;
+
+        l_filter_tot_constrain /= testTotal;
+        l3_filter_tot_constrain /= testTotal;
+        l1_filter_tot_constrain /= testTotal;
+
+        r_filter_tot_constrain /= testTotal;
+        r3_filter_tot_constrain /= testTotal;
+        r1_filter_tot_constrain /= testTotal;
+
+        printf("type constraint results:\n");
+
+        printf("metric:\t\t\t MRR \t\t MR \t\t hit@10 \t hit@3  \t hit@1 \n");
+        printf("l(raw):\t\t\t %f \t %f \t %f \t %f \t %f \n", l_reci_rank_constrain, l_rank_constrain, l_tot_constrain, l3_tot_constrain, l1_tot_constrain);
+        printf("r(raw):\t\t\t %f \t %f \t %f \t %f \t %f \n", r_reci_rank_constrain, r_rank_constrain, r_tot_constrain, r3_tot_constrain, r1_tot_constrain);
+        printf("averaged(raw):\t\t %f \t %f \t %f \t %f \t %f \n",
+                (l_reci_rank_constrain+r_reci_rank_constrain)/2, (l_rank_constrain+r_rank_constrain)/2, (l_tot_constrain+r_tot_constrain)/2, (l3_tot_constrain+r3_tot_constrain)/2, (l1_tot_constrain+r1_tot_constrain)/2);
+        printf("\n");
+        printf("l(filter):\t\t %f \t %f \t %f \t %f \t %f \n", l_filter_reci_rank_constrain, l_filter_rank_constrain, l_filter_tot_constrain, l3_filter_tot_constrain, l1_filter_tot_constrain);
+        printf("r(filter):\t\t %f \t %f \t %f \t %f \t %f \n", r_filter_reci_rank_constrain, r_filter_rank_constrain, r_filter_tot_constrain, r3_filter_tot_constrain, r1_filter_tot_constrain);
+        printf("averaged(filter):\t %f \t %f \t %f \t %f \t %f \n",
+                (l_filter_reci_rank_constrain+r_filter_reci_rank_constrain)/2, (l_filter_rank_constrain+r_filter_rank_constrain)/2, (l_filter_tot_constrain+r_filter_tot_constrain)/2, (l3_filter_tot_constrain+r3_filter_tot_constrain)/2, (l1_filter_tot_constrain+r1_filter_tot_constrain)/2);
+    }
+}
+
+/*=====================================================================================
+triple classification
+======================================================================================*/
+Triple *negTestList;
+extern "C"
+void getNegTest() {
+    negTestList = (Triple *)calloc(testTotal, sizeof(Triple));
+    for (INT i = 0; i < testTotal; i++) {
+        negTestList[i] = testList[i];
+        negTestList[i].t = corrupt(testList[i].h, testList[i].r);
+    }
+}
+
+Triple *negValidList;
+extern "C"
+void getNegValid() {
+    negValidList = (Triple *)calloc(validTotal, sizeof(Triple));
+    for (INT i = 0; i < validTotal; i++) {
+        negValidList[i] = validList[i];
+        negValidList[i].t = corrupt(validList[i].h, validList[i].r);
+    }   
+}
+
+extern "C"
+void getTestBatch(INT *ph, INT *pt, INT *pr, INT *nh, INT *nt, INT *nr) {
+    getNegTest();
+    for (INT i = 0; i < testTotal; i++) {
+        ph[i] = testList[i].h;
+        pt[i] = testList[i].t;
+        pr[i] = testList[i].r;
+        nh[i] = negTestList[i].h;
+        nt[i] = negTestList[i].t;
+        nr[i] = negTestList[i].r;
+    }
+}
+
+extern "C"
+void getValidBatch(INT *ph, INT *pt, INT *pr, INT *nh, INT *nt, INT *nr) {
+    getNegValid();
+    for (INT i = 0; i < validTotal; i++) {
+        ph[i] = validList[i].h;
+        pt[i] = validList[i].t;
+        pr[i] = validList[i].r;
+        nh[i] = negValidList[i].h;
+        nt[i] = negValidList[i].t;
+        nr[i] = negValidList[i].r;
+    }
+}
+
+REAL threshEntire;
+extern "C"
+void getBestThreshold(REAL *relThresh, REAL *score_pos, REAL *score_neg) {
+    REAL interval = 0.01;
+    REAL min_score, max_score, bestThresh, tmpThresh, bestAcc, tmpAcc;
+    INT n_interval, correct, total;
+    for (INT r = 0; r < relationTotal; r++) {
+        if (validLef[r] == -1) continue;
+        total = (validRig[r] - validLef[r] + 1) * 2;
+        min_score = score_pos[validLef[r]];
+        if (score_neg[validLef[r]] < min_score) min_score = score_neg[validLef[r]];
+        max_score = score_pos[validLef[r]];
+        if (score_neg[validLef[r]] > max_score) max_score = score_neg[validLef[r]];
+        for (INT i = validLef[r]+1; i <= validRig[r]; i++) {
+            if(score_pos[i] < min_score) min_score = score_pos[i];
+            if(score_pos[i] > max_score) max_score = score_pos[i];
+            if(score_neg[i] < min_score) min_score = score_neg[i];
+            if(score_neg[i] > max_score) max_score = score_neg[i];
+        }
+        n_interval = INT((max_score - min_score)/interval);
+        for (INT i = 0; i <= n_interval; i++) {
+            tmpThresh = min_score + i * interval;
+            correct = 0;
+            for (INT j = validLef[r]; j <= validRig[r]; j++) {
+                if (score_pos[j] <= tmpThresh) correct ++;
+                if (score_neg[j] > tmpThresh) correct ++;
+            }
+            tmpAcc = 1.0 * correct / total;
+            if (i == 0) {
+                bestThresh = tmpThresh;
+                bestAcc = tmpAcc;
+            } else if (tmpAcc > bestAcc) {
+                bestAcc = tmpAcc;
+                bestThresh = tmpThresh;
+            }
+        }
+        relThresh[r] = bestThresh;
+    }
+}
+
+REAL *testAcc;
+REAL aveAcc;
+extern "C"
+//EDIT
+void test_triple_classification(REAL *relThresh, REAL *score_pos, REAL *score_neg, REAL *acc_addr) {
+    testAcc = (REAL *)calloc(relationTotal, sizeof(REAL));
+    INT aveCorrect = 0, aveTotal = 0;
+    REAL aveAcc;
+    for (INT r = 0; r < relationTotal; r++) {
+        if (validLef[r] == -1 || testLef[r] ==-1) continue;
+        INT correct = 0, total = 0;
+        for (INT i = testLef[r]; i <= testRig[r]; i++) {
+            if (score_pos[i] <= relThresh[r]) correct++;
+            if (score_neg[i] > relThresh[r]) correct++;
+            total += 2;
+        }
+        testAcc[r] = 1.0 * correct / total;
+        aveCorrect += correct; 
+        aveTotal += total;
+    }
+    //EDIT
+    aveAcc = 1.0 * aveCorrect / aveTotal;
+    printf("triple classification accuracy is %lf\n", aveAcc);
+    acc_addr[0] = 1.0 * aveCorrect / aveTotal;
+}
+
+
+
+#endif
diff --git a/base/Triple.h b/base/Triple.h
new file mode 100644
index 0000000..66f1fec
--- /dev/null
+++ b/base/Triple.h
@@ -0,0 +1,36 @@
+#ifndef TRIPLE_H
+#define TRIPLE_H
+#include "Setting.h"
+
+struct Triple {
+
+	INT h, r, t;
+
+	static INT minimal(INT a,INT b) {
+		if (a > b) return b;
+		return a;
+	}
+	
+	static bool cmp_list(const Triple &a, const Triple &b) {
+		return (minimal(a.h, a.t) > minimal(b.h, b.t));
+	}
+
+	static bool cmp_head(const Triple &a, const Triple &b) {
+		return (a.h < b.h)||(a.h == b.h && a.r < b.r)||(a.h == b.h && a.r == b.r && a.t < b.t);
+	}
+
+	static bool cmp_tail(const Triple &a, const Triple &b) {
+		return (a.t < b.t)||(a.t == b.t && a.r < b.r)||(a.t == b.t && a.r == b.r && a.h < b.h);
+	}
+
+	static bool cmp_rel(const Triple &a, const Triple &b) {
+		return (a.h < b.h)||(a.h == b.h && a.t < b.t)||(a.h == b.h && a.t == b.t && a.r < b.r);
+	}
+
+	static bool cmp_rel2(const Triple &a, const Triple &b) {
+		return (a.r < b.r)||(a.r == b.r && a.h < b.h)||(a.r == b.r && a.h == b.h && a.t < b.t);
+	}
+
+};
+
+#endif
diff --git a/base/Valid.h b/base/Valid.h
new file mode 100644
index 0000000..4ec29f3
--- /dev/null
+++ b/base/Valid.h
@@ -0,0 +1,78 @@
+#ifndef VALID_H
+#define VALID_H
+#include "Setting.h"
+#include "Reader.h"
+#include "Corrupt.h"
+
+INT lastValidHead = 0;
+INT lastValidTail = 0;
+	
+REAL l_valid_filter_tot = 0;
+REAL r_valid_filter_tot = 0;
+
+extern "C"
+void validInit() {
+    lastValidHead = 0;
+    lastValidTail = 0;
+    l_valid_filter_tot = 0;
+    r_valid_filter_tot = 0;
+}
+
+extern "C"
+void getValidHeadBatch(INT *ph, INT *pt, INT *pr) {
+    for (INT i = 0; i < entityTotal; i++) {
+        ph[i] = i;
+        pt[i] = validList[lastValidHead].t;
+        pr[i] = validList[lastValidHead].r;
+    }
+}
+
+extern "C"
+void getValidTailBatch(INT *ph, INT *pt, INT *pr) {
+    for (INT i = 0; i < entityTotal; i++) {
+        ph[i] = validList[lastValidTail].h;
+        pt[i] = i;
+        pr[i] = validList[lastValidTail].r;
+    }
+}
+
+extern "C"
+void validHead(REAL *con) {
+    INT h = validList[lastValidHead].h;
+    INT t = validList[lastValidHead].t;
+    INT r = validList[lastValidHead].r;
+    REAL minimal = con[h];
+    INT l_filter_s = 0;
+    for (INT j = 0; j < entityTotal; j++) {
+        if (j != h) {
+            REAL value = con[j];
+            if (value < minimal && ! _find(j, t, r)) l_filter_s += 1;
+        }
+    }
+    if (l_filter_s < 10) l_valid_filter_tot += 1;
+    lastValidHead ++;
+}
+
+extern "C"
+void validTail(REAL *con) {
+    INT h = validList[lastValidTail].h;
+    INT t = validList[lastValidTail].t;
+    INT r = validList[lastValidTail].r;
+    REAL minimal = con[t];
+    INT r_filter_s = 0;
+    for (INT j = 0; j < entityTotal; j++) {
+        if (j != t) {
+            REAL value = con[j];
+            if (value < minimal && ! _find(h, j, r)) r_filter_s += 1;
+        }
+    }
+    if (r_filter_s < 10) r_valid_filter_tot += 1;
+    lastValidTail ++;
+}
+
+extern "C"
+REAL getValidHit10() {
+    return (l_valid_filter_tot / validTotal + r_valid_filter_tot / validTotal) / 2;;
+}
+
+#endif
diff --git a/distribute_training.py b/distribute_training.py
new file mode 100644
index 0000000..caa5b46
--- /dev/null
+++ b/distribute_training.py
@@ -0,0 +1,292 @@
+from Config import Config
+from TransE import TransE
+from TransH import TransH
+from TransR import TransR
+from TransD import TransD
+import tensorflow as tf
+from tensorflowonspark import TFNode
+import os
+import numpy as np
+from tensorflow.python.training import session_run_hook
+from tensorflow.contrib.training.python.training.device_setter import GreedyLoadBalancingStrategy, byte_size_load_fn
+import sys
+
+
+#if set to Ture prints additional debug information
+DEBUG = True
+
+
+def get_conf_to_update_model(output_path):
+    con = Config(init_new_entities=True)
+
+    ckpt = None
+    with open(output_path + "/checkpoint", 'r') as f:
+        first_line = f.readline()
+        ckpt = first_line.split(':')[1].strip().replace('"', '')
+    if DEBUG: print("Checkpoint file is: " + ckpt)
+
+    con.import_model(ckpt)
+
+    return con, ckpt
+
+
+def get_conf(argv=None):
+    if argv == None: argv = sys.argv
+
+    con = Config()
+    con.set_in_path(argv.input_path)
+    con.set_export_files(argv.output_path)
+    con.set_valid_triple_classification(True)        #to perform early stop on validation accuracy
+    # con.set_work_threads(argv.working_threads)
+    con.set_train_times(argv.train_times)
+    con.set_nbatches(argv.n_batches)
+    con.set_alpha(argv.alpha)
+    con.set_margin(argv.margin)
+
+    if argv.bern_flag:
+        con.set_bern(1)
+
+    if argv.ent_dimension != 0 and argv.rel_dimension != 0:
+        con.set_ent_dimension(argv.ent_dimension)
+        con.set_rel_dimension(argv.rel_dimension)
+    else:
+        con.set_dimension(argv.embedding_dimension)
+
+    con.set_ent_neg_rate(argv.ent_neg_rate)
+    con.set_rel_neg_rate(argv.rel_neg_rate)
+    con.set_opt_method(argv.optimizer)
+    con.init()
+
+    if argv.model.lower() == "transe":
+        con.set_model(TransE)
+    elif argv.model.lower() == "transh":
+        con.set_model(TransH)
+    elif argv.model.lower() == "transr":
+        con.set_model(TransR)
+    else:
+        con.set_model(TransD)
+
+    return con
+
+
+def create_model(con):
+    with tf.variable_scope("", reuse=None, initializer = tf.contrib.layers.xavier_initializer(uniform = True)):
+        trainModel = con.model(config = con)
+
+        with tf.name_scope("input"):
+            trainModel.input_def()
+
+        with tf.name_scope("embedding"):
+            trainModel.embedding_def()
+
+        with tf.name_scope("loss"):
+            trainModel.loss_def()
+            tf.summary.scalar("loss", trainModel.loss)  #summary 1
+
+        with tf.name_scope("predict"):
+            trainModel.predict_def()
+
+        if con.opt_method == "Adam" or con.opt_method == "adam":
+            optimizer = tf.train.AdamOptimizer(con.alpha)
+        else:
+            optimizer = tf.train.GradientDescentOptimizer(con.alpha)
+
+        global_step = tf.train.get_or_create_global_step()
+        train_op = optimizer.minimize(trainModel.loss, global_step=global_step)
+        init_op = tf.initialize_all_variables()
+        saver = tf.train.Saver(max_to_keep=sys.argv.early_stop_patience+5)
+
+        return trainModel, global_step, train_op, init_op, saver, tf.summary.merge_all()
+
+
+def get_last_step():
+    last_global_step = 0
+    try:
+        if os.path.isfile(sys.argv.output_path+"/checkpoint"):
+            if DEBUG:
+                print("Checkpoint file founded")
+                print("Reading last global step...")
+
+            with open(sys.argv.output_path+"/checkpoint", "r") as f:
+                line = f.readline().replace('"','').split(":")[1].split("/")
+                last = int(line[len(line)-1].split("-")[1].strip())
+                last_global_step = last
+
+            if DEBUG: print("Last global step: " + str(last_global_step))
+        else:
+            if DEBUG: print("Checkpoint file not founded")
+    except Exception as e:
+        print("Error occured during last global step reading:")
+        print(e)
+    finally:
+        return last_global_step
+
+
+def main_fun(argv, ctx):
+    job_name = ctx.job_name
+    task_index = ctx.task_index
+    sys.argv = argv
+
+
+    if DEBUG: print("Starting cluster and server...")
+    cluster, server = TFNode.start_cluster_server(ctx, num_gpus=argv.num_gpus, rdma=False)
+    if DEBUG: print("Cluster and server started")
+
+
+    if job_name == "ps":
+        print("PS: joining...")
+        server.join()
+        if DEBUG: print("PS: join finished")
+
+    elif job_name == "worker":
+        print("WORKER: training...")
+
+        #Online learning
+        last_global_step = get_last_step()
+
+
+        #set config
+        if DEBUG: print("Creating conf...")
+        con = get_conf()
+
+
+        with tf.device(tf.train.replica_device_setter(
+            worker_device="/job:worker/task:%d" % task_index,
+            cluster=cluster,
+            ps_strategy=GreedyLoadBalancingStrategy(num_tasks=argv.num_ps, load_fn=byte_size_load_fn))):
+
+            if DEBUG: print("Creating model...")
+            trainModel, global_step, train_op, init_op, saver, summary_op = create_model(con)
+
+
+
+        if DEBUG: print("Creating Hooks, Scaffold, FileWriter...")
+
+        iterations = con.train_times * con.nbatches + last_global_step
+        hooks=[tf.train.StopAtStepHook(last_step=iterations)]
+        scaffold = tf.train.Scaffold(init_op=init_op, saver=saver, summary_op=summary_op)
+        tf.summary.FileWriter("tensorboard_%d" % ctx.worker_num, graph=tf.get_default_graph())
+
+
+        if DEBUG: print("Starting MonitoredTrainingSession...")
+        with tf.train.MonitoredTrainingSession(master=server.target,
+                                               is_chief=(task_index == 0),
+                                               scaffold=scaffold,
+                                               checkpoint_dir=argv.output_path,
+                                               save_summaries_steps=1,
+                                               save_checkpoint_steps=1*con.nbatches,
+                                               hooks=hooks,
+                                               summary_dir="tensorboard_%d" % ctx.worker_num
+                                               ) as sess:
+            if DEBUG:
+                print("Monitoring training sessions started")
+                print("Task index is: {}".format(task_index))
+
+            #init local worker vars
+            best_acc = np.finfo('float32').min
+            best_loss = np.finfo('float32').max
+            wait_steps_acc = 0
+            wait_steps_loss = 0
+            best_model_global_step_loss = 0
+            best_model_global_step_acc = 0
+            patience = sys.argv.early_stop_patience
+            stopping_step = sys.argv.early_stop_stopping_step * con.nbatches
+            to_reach_step = sys.argv.early_stop_start_step * con.nbatches + last_global_step
+            con.lib.getValidBatch(con.valid_pos_h_addr, con.valid_pos_t_addr, con.valid_pos_r_addr, con.valid_neg_h_addr, con.valid_neg_t_addr, con.valid_neg_r_addr)
+
+            while not sess.should_stop():
+                con.sampling()
+
+                feed_dict = {
+                    trainModel.batch_h: con.batch_h,
+                    trainModel.batch_t: con.batch_t,
+                    trainModel.batch_r: con.batch_r,
+                    trainModel.batch_y: con.batch_y
+                }
+
+                _, loss, g = sess.run([train_op, trainModel.loss, global_step], feed_dict)
+                print('Global step: {} Epoch: {} Batch: {} loss: {}'.format(g, int( (g-last_global_step) /con.nbatches), int( (g - last_global_step) % con.nbatches), loss))
+
+
+                ################## EARLY STOP ##################
+                if (task_index != 0) and (g >= to_reach_step):
+                    to_reach_step += stopping_step
+                    if os.path.exists(sys.argv.output_path+"/stop.txt"):
+                        print('\nEarly stop happened in chief worker\n')
+                        break
+
+
+                if (task_index == 0) and (not sess.should_stop()) and (g >= to_reach_step):
+                    to_reach_step += stopping_step
+
+                    ################## ACCURACY ##################
+                    feed_dict[trainModel.predict_h] = con.valid_pos_h
+                    feed_dict[trainModel.predict_t] = con.valid_pos_t
+                    feed_dict[trainModel.predict_r] = con.valid_pos_r
+                    res_pos = sess.run(trainModel.predict, feed_dict)
+
+                    feed_dict[trainModel.predict_h] = con.valid_neg_h
+                    feed_dict[trainModel.predict_t] = con.valid_neg_t
+                    feed_dict[trainModel.predict_r] = con.valid_neg_r
+                    res_neg = sess.run(trainModel.predict, feed_dict)
+
+                    con.lib.getBestThreshold(con.relThresh_addr, res_pos.__array_interface__['data'][0], res_neg.__array_interface__['data'][0])
+                    con.lib.test_triple_classification(con.relThresh_addr, res_pos.__array_interface__['data'][0], res_neg.__array_interface__['data'][0], con.acc_addr)
+                    acc = con.acc[0]
+
+                    if DEBUG:
+                        print("\n[ Early Stop Check (Accuracy) ]")
+                        print("Best Accuracy = %.10f" %(best_acc))
+                        print("Accuracy after run  =  %.10f" %(acc))
+
+                    if acc > best_acc:
+                        best_acc = acc
+                        wait_steps_acc = 0
+                        if DEBUG: print("New best Accuracy founded. Wait steps reset.")
+                        best_model_global_step_acc = g
+
+                    elif wait_steps_acc < patience:
+                        wait_steps_acc += 1
+                        if DEBUG: print("Wait steps Accuracy incremented: {}\n".format(wait_steps_acc))
+
+
+                    if wait_steps_acc >= patience:
+                        print('Accuracy early stop. Accuracy has not been improved enough in {} times'.format(patience))
+                        with open(sys.argv.output_path+"/stop.txt", "w") as stop_file:
+                            stop_file.write(str(best_model_global_step_acc)+"\n")
+                        break
+
+
+                    ################## LOSS ##################
+                    if DEBUG:
+                        print("\n[ Early Stop Checking (Loss) ]")
+                        print("Best loss = %.10f" %(best_loss))
+                        print("Loss after run  =  %.10f" %(loss))
+
+                    if loss < best_loss:
+                        best_loss = loss
+                        wait_steps_loss = 0
+                        if DEBUG: print("New best loss founded. Wait steps reset.")
+                        best_model_global_step_loss = g
+
+                    elif wait_steps_loss < patience:
+                        wait_steps_loss += 1
+                        if DEBUG: print("Wait steps loss incremented: {}\n".format(wait_steps_loss))
+
+
+                    if wait_steps_loss >= patience:
+                        print('Loss early stop. Losses has not been improved enough in {} times'.format(patience))
+                        with open(sys.argv.output_path+"/stop.txt", "w") as stop_file:
+                            stop_file.write(str(best_model_global_step_loss)+"\n")
+                        break
+
+        if DEBUG: print("Monitoring training sessions should stop now")
+
+
+
+
+
+
+
+
+
diff --git a/main_spark.py b/main_spark.py
new file mode 100644
index 0000000..b59e059
--- /dev/null
+++ b/main_spark.py
@@ -0,0 +1,370 @@
+import argparse
+from pyspark.context import SparkContext
+from pyspark.conf import SparkConf
+from tensorflowonspark import TFCluster
+import distribute_training
+import tensorflow as tf
+import sys
+import os
+import traceback
+import time
+import shutil
+from os import path
+
+os.environ["CUDA_VISIBLE_DEVICES"]="-1"
+
+DEBUG = distribute_training.DEBUG
+
+NEW_BATCH_TRIPLES_FILE_NAME = 'batch2id.txt'
+NEW_BATCH_ENTITIES_FILE_NAME = 'batchEntity2id.txt'
+NEW_BATCH_TEST_FILE_NAME = 'batchTest2id.txt'
+NEW_BATCH_VALID_FILE_NAME = 'batchValid2id.txt'
+
+ENTITIES_FILE_NAME = 'entity2id.txt'
+TRIPLES_FILE_NAME = 'train2id.txt'
+TEST_FILE_NAME = 'test2id.txt'
+VALID_FILE_NAME = 'valid2id.txt'
+
+ENTITY_EMBEDDING_TENSOR_NAME = 'ent_embeddings'
+
+
+def update_entities_and_model():
+    n_entities = 0
+    n_new_entities = 0
+    final_entity_size = 0
+    batch_entities = []
+    entity_lines = []
+
+    ######### READ NEW ENTITIES #########
+    with open(sys.argv.input_path+NEW_BATCH_ENTITIES_FILE_NAME, 'r') as f:
+        n_new_entities = int(f.readline().strip())
+        if n_new_entities > 0:
+            for _ in range(n_new_entities):
+                batch_entities.append((f.readline()))
+
+
+    ######### READ OLD ENTITIES #########
+    with open(sys.argv.input_path+ENTITIES_FILE_NAME) as f:
+        entity_lines = f.readlines()
+    n_entities = int(entity_lines[0])
+    final_entity_size = n_entities + n_new_entities
+    if DEBUG: print("Number of new entities in batch: " + str(n_new_entities))
+
+
+    ######### UPDATE THE MODEL #########
+    con, ckpt = distribute_training.get_conf_to_update_model(sys.argv.output_path)
+    vars = []
+
+    if DEBUG: print("\nGLOBAL VARS FOUNDED IN CHECKPOINT:\n")
+    with con.graph.as_default():
+        with con.sess.as_default():
+            for v in tf.global_variables():
+                if DEBUG: print(str(v.name) + " " + str(v.shape))
+                vars.append(v)
+    if DEBUG: print('\n')
+
+
+    if DEBUG: print("NEW GLOBAL VARIABLES")
+    graph = tf.Graph()
+    with graph.as_default():
+        sess = tf.Session()
+        with sess.as_default():
+            for v in vars:
+                current_name = v.name.split(':')[0]
+
+                if (current_name == ENTITY_EMBEDDING_TENSOR_NAME) and (final_entity_size > n_entities):
+                    tmp = tf.get_variable(name=current_name, shape=[final_entity_size, v.shape[1]], initializer=tf.contrib.layers.xavier_initializer(uniform = False), dtype=v.dtype)
+                    sess.run(tf.initialize_variables([tmp]))
+                    tmp_value = con.sess.run(v)
+                    sess.run(tf.scatter_update(tmp, [i for i in range(0, n_entities)], tmp_value))
+
+                elif (current_name in [ENTITY_EMBEDDING_TENSOR_NAME+'/Adam', ENTITY_EMBEDDING_TENSOR_NAME+'/Adam_1']) and (final_entity_size > n_entities):
+                    tmp = tf.get_variable(name=current_name, shape=[final_entity_size, v.shape[1]], initializer=tf.zeros_initializer(), dtype=v.dtype)
+                    sess.run(tf.initialize_variables([tmp]))
+                    tmp_value = con.sess.run(v)
+                    sess.run(tf.scatter_update(tmp, [i for i in range(0, n_entities)], tmp_value))
+
+                else:
+                    tmp = tf.get_variable(name=current_name, shape=v.shape, dtype=v.dtype)
+                    tmp_value = con.sess.run(v)
+                    sess.run(tf.assign(tmp, tmp_value))
+
+            for v in tf.global_variables():
+                print(str(v.name) + " " + str(v.shape))
+
+            saver = tf.train.Saver()
+            saver.save(sess, ckpt, write_state=False)
+
+
+    ######### UPDATE ENTITY FILE #########
+    if n_new_entities > 0:
+        #update number of entities
+        entity_lines[0] = str(final_entity_size) + "\n"
+
+        #update entities: append the new entities at the end of the file
+        entity_lines = entity_lines + batch_entities
+
+        #update entity2id
+        with open(sys.argv.input_path+ENTITIES_FILE_NAME, "w") as f:
+            f.writelines(entity_lines)
+    if DEBUG: print("Entity file updated")
+
+    return n_new_entities, final_entity_size
+
+
+def update_triples(file_name_to_update, file_name_batch):
+    batch_triples_size = 0
+    batch_triples = []
+
+    #open batch file
+    with open(sys.argv.input_path + file_name_batch) as f:
+        batch_triples_size = int(f.readline().strip())
+        if batch_triples_size > 0:
+            for _ in range(batch_triples_size):
+                batch_triples.append(f.readline())
+    print("Number of new lines: " + str(batch_triples_size))
+
+    if batch_triples_size > 0:
+        #open file
+        with open(sys.argv.input_path + file_name_to_update) as f:
+            lines = f.readlines()
+
+        #update number of triples
+        lines[0] = str(int(lines[0]) + batch_triples_size) + "\n"
+
+        #update triples
+        lines = lines + batch_triples       #append the new triples at the end of the file
+
+        #update file
+        with open(sys.argv.input_path + file_name_to_update, "w") as f:
+            f.writelines(lines)
+    if DEBUG: print("File updated")
+
+
+def feed_batch():
+    current_time = time.time()
+    if DEBUG: print("New batch file founded")
+    try:
+        if DEBUG: print("Updating "+ENTITIES_FILE_NAME+" and model tensors...")
+        update_entities_and_model()
+
+        if DEBUG: print("Updating "+TRIPLES_FILE_NAME+"...")
+        update_triples(TRIPLES_FILE_NAME, NEW_BATCH_TRIPLES_FILE_NAME)
+
+        if DEBUG: print("Updating "+TEST_FILE_NAME+"...")
+        update_triples(TEST_FILE_NAME, NEW_BATCH_TEST_FILE_NAME)
+
+        if DEBUG: print("Updating "+VALID_FILE_NAME+"...")
+        update_triples(VALID_FILE_NAME, NEW_BATCH_VALID_FILE_NAME)
+
+        elapsed_time = time.time() - current_time
+        print("Time elapsed for new entities initialization: {}".format(elapsed_time))
+
+        return elapsed_time
+
+    except Exception as e:
+        print("Error occured while feeding new batch:")
+        traceback.print_exc()
+        print(e)
+
+
+def is_new_batch():
+    return os.path.isfile(sys.argv.input_path+NEW_BATCH_TRIPLES_FILE_NAME) and \
+           os.path.isfile(sys.argv.input_path+NEW_BATCH_ENTITIES_FILE_NAME) and \
+            os.path.isfile(sys.argv.input_path+NEW_BATCH_TEST_FILE_NAME) and \
+           os.path.isfile(sys.argv.input_path+NEW_BATCH_VALID_FILE_NAME)
+
+
+def remove_batch_files():
+    os.remove(sys.argv.input_path+NEW_BATCH_TRIPLES_FILE_NAME)
+    os.remove(sys.argv.input_path+NEW_BATCH_ENTITIES_FILE_NAME)
+    os.remove(sys.argv.input_path+NEW_BATCH_TEST_FILE_NAME)
+    os.remove(sys.argv.input_path+NEW_BATCH_VALID_FILE_NAME)
+
+
+def n_n():
+    lef = {}
+    rig = {}
+    rellef = {}
+    relrig = {}
+
+    triple = open(sys.argv.input_path+"train2id.txt", "r")
+    valid = open(sys.argv.input_path+"valid2id.txt", "r")
+    test = open(sys.argv.input_path+"test2id.txt", "r")
+
+    tot = (int)(triple.readline())
+    for i in range(tot):
+        content = triple.readline()
+        h,t,r = content.strip().split()
+        if not (h,r) in lef:
+            lef[(h,r)] = []
+        if not (r,t) in rig:
+            rig[(r,t)] = []
+        lef[(h,r)].append(t)
+        rig[(r,t)].append(h)
+        if not r in rellef:
+            rellef[r] = {}
+        if not r in relrig:
+            relrig[r] = {}
+        rellef[r][h] = 1
+        relrig[r][t] = 1
+
+    tot = (int)(valid.readline())
+    for i in range(tot):
+        content = valid.readline()
+        h,t,r = content.strip().split()
+        if not (h,r) in lef:
+            lef[(h,r)] = []
+        if not (r,t) in rig:
+            rig[(r,t)] = []
+        lef[(h,r)].append(t)
+        rig[(r,t)].append(h)
+        if not r in rellef:
+            rellef[r] = {}
+        if not r in relrig:
+            relrig[r] = {}
+        rellef[r][h] = 1
+        relrig[r][t] = 1
+
+    tot = (int)(test.readline())
+    for i in range(tot):
+        content = test.readline()
+        h,t,r = content.strip().split()
+        if not (h,r) in lef:
+            lef[(h,r)] = []
+        if not (r,t) in rig:
+            rig[(r,t)] = []
+        lef[(h,r)].append(t)
+        rig[(r,t)].append(h)
+        if not r in rellef:
+            rellef[r] = {}
+        if not r in relrig:
+            relrig[r] = {}
+        rellef[r][h] = 1
+        relrig[r][t] = 1
+
+    test.close()
+    valid.close()
+    triple.close()
+
+    f = open(sys.argv.input_path+"type_constrain.txt", "w")
+    f.write("%d\n"%(len(rellef)))
+    for i in rellef:
+        f.write("%s\t%d"%(i,len(rellef[i])))
+        for j in rellef[i]:
+            f.write("\t%s"%(j))
+        f.write("\n")
+        f.write("%s\t%d"%(i,len(relrig[i])))
+        for j in relrig[i]:
+            f.write("\t%s"%(j))
+        f.write("\n")
+    f.close()
+
+
+
+if __name__ == '__main__':
+    if DEBUG: print("Creating Spark Context...")
+    sc = SparkContext(conf=SparkConf().setAppName('OpenKEonSpark'))
+
+
+    if DEBUG: print("Parsing arguments...")
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--cluster_size", help="number of nodes in the cluster", type=int, default=int(sc._conf.get("spark.executor.instances")))
+    parser.add_argument("--num_ps", help="number of ps nodes", type=int, default=1)
+    parser.add_argument("--num_gpus", help="number of gpus to use", type=int, default=0)
+    parser.add_argument("--input_path", help="dataset absolute path", type=str, default="/home/")
+    parser.add_argument("--output_path", help="model output absolute path", type=str, default="/home/")
+    # parser.add_argument("--working_threads", help="no. threads used during sampling", type=int, default=8)
+    parser.add_argument("--train_times", help="no. epochs", type=int, default=1000)
+    parser.add_argument("--n_batches", help="no. batches", type=int, default=0)
+    parser.add_argument("--alpha", help="learning rate", type=float, default=0.001)
+    parser.add_argument("--margin", help="margin hyperparameter used during training", type=float, default=1.0)
+    parser.add_argument("--bern_flag", help="use bern method for sampling", type=bool, default=False)
+    parser.add_argument("--embedding_dimension", help="embedding dimension (both entities and rel)", type=int, default=64)
+    parser.add_argument("--ent_dimension", help="entities embedding dimension", type=int, default=0)
+    parser.add_argument("--rel_dimension", help="relations embedding dimension", type=int, default=0)
+    parser.add_argument("--ent_neg_rate", help="number of negative triples generated by corrupting the entity", type=int, default=1)
+    parser.add_argument("--rel_neg_rate", help="number of negative triples generated by corrupting the realtion", type=int, default=0)
+    parser.add_argument("--optimizer", help="Optimization algorithm", type=str, default="SGD")
+    parser.add_argument("--early_stop_patience", help="no. epochs to wait for loss improvement before early stop", type=int, default=5)
+    parser.add_argument("--early_stop_stopping_step", help="perfrom early stop each stopping step", type=int, default=1)
+    parser.add_argument("--early_stop_start_step", help="perfrom early stop from start step", type=int, default=1)
+    parser.add_argument("--model", help="model to be used", type=str, default="TransE")
+
+
+    (args, remainder) = parser.parse_known_args()
+    num_workers = args.cluster_size - args.num_ps
+    print("===== num_executors={}, num_workers={}, num_ps={}".format(args.cluster_size, num_workers, args.num_ps))
+
+
+    if DEBUG: print("Setting batch files if present...")
+    sys.argv = args
+    if is_new_batch(): feed_batch()
+
+
+    if DEBUG: print("Generating type files...")
+    n_n()
+
+
+    if DEBUG: print("Removing stop file...")
+    try:
+        os.remove(args.output_path+"/stop.txt")
+    except:
+        pass
+
+
+    if DEBUG: print("Creating cluster...")
+    training_time = time.time()
+    cluster = TFCluster.run(sc, distribute_training.main_fun, args, args.cluster_size, args.num_ps, True, TFCluster.InputMode.TENSORFLOW)
+
+
+
+    if DEBUG: print("Shutdowning cluster...")
+    cluster.shutdown()
+    training_time = time.time() - training_time
+
+
+
+    if DEBUG: print("Removing batch files if present...")
+    if is_new_batch(): remove_batch_files()
+
+
+
+    if DEBUG: print("Printing time information on files...")
+    with open(args.output_path+'/time.txt', 'w') as f:
+        f.write("Training time: " + str(training_time) + "\n")
+
+
+
+    if DEBUG: print("Restoring the best model founded during training...")
+    if path.exists(args.output_path+"/stop.txt"):
+        step = None
+        with open(args.output_path+"/stop.txt", "r") as f:
+            step = int(f.readline().strip())
+
+        if step != None:
+            min_diff = sys.maxsize
+            nearest = None
+            with open(args.output_path+"/checkpoint", "r") as ckpt_file:
+                lines = ckpt_file.readlines()
+
+            for line in lines:
+                l = line.replace('"','').split("/")
+                n = int(l[len(l) - 1].split("-")[1])
+                diff = abs(step - n)
+                if diff < min_diff:
+                    nearest = n
+                    min_diff = diff
+
+            if nearest != None:
+                with open(args.output_path+"/checkpoint", "w") as ckpt_file:
+                    ckpt_file.write('model_checkpoint_path: "'+args.output_path+'/model.ckpt-'+str(nearest)+'"\n')
+                    ckpt_file.write('all_model_checkpoint_paths: "'+args.output_path+'/model.ckpt-'+str(nearest)+'"\n')
+
+            for f in os.listdir(args.output_path):
+                if f.startswith("model") and len(f.split("model.ckpt-"+str(nearest))) == 1:
+                    os.remove(args.output_path+"/"+f)
+
+
+    if DEBUG: print("Program finished")
+
diff --git a/make.sh b/make.sh
new file mode 100644
index 0000000..6b91ff7
--- /dev/null
+++ b/make.sh
@@ -0,0 +1 @@
+g++ ./base/Base.cpp -fPIC -shared -o ./release/Base.so -pthread -O3 -march=native -std=c++11
diff --git a/release/Base.so b/release/Base.so
new file mode 100755
index 0000000000000000000000000000000000000000..18db0000be66d0b6293ae01f051a43a73c9e4f92
GIT binary patch
literal 74416
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
KXJjx=#eW0o^Dc`3

literal 0
HcmV?d00001

diff --git a/run.sh b/run.sh
new file mode 100644
index 0000000..a9aa39c
--- /dev/null
+++ b/run.sh
@@ -0,0 +1,249 @@
+#!/bin/bash
+# On ps0.example.com:
+python3 example_train_transe_d.py \
+     --ps_hosts=ps0.example.com:2222,ps1.example.com:2222 \
+     --worker_hosts=worker0.example.com:2222,worker1.example.com:2222 \
+     --job_name=ps --task_index=0
+# On ps1.example.com:
+python3 example_train_transe_d.py \
+     --ps_hosts=ps0.example.com:2222,ps1.example.com:2222 \
+     --worker_hosts=worker0.example.com:2222,worker1.example.com:2222 \
+     --job_name=ps --task_index=1
+# On worker0.example.com:
+python3 example_train_transe_d.py \
+     --ps_hosts=ps0.example.com:2222,ps1.example.com:2222 \
+     --worker_hosts=worker0.example.com:2222,worker1.example.com:2222 \
+     --job_name=worker --task_index=0
+# On worker1.example.com:
+python3 example_train_transe_d.py \
+     --ps_hosts=ps0.example.com:2223,ps1.example.com:2223 \
+     --worker_hosts=worker0.example.com:2223,worker1.example.com:2223 \
+     --job_name=worker --task_index=1
+
+
+python3 example_train_transe_d.py \
+     --ps_hosts=ps0.example.com:2225 \
+     --worker_hosts=worker0.example.com:2225 \
+     --job_name=ps --task_index=0
+
+python3 example_train_transe_d.py \
+     --ps_hosts=ps0.example.com:2224,ps1.example.com:2224 \
+     --worker_hosts=worker0.example.com:2224,worker1.example.com:2224 \
+     --job_name=worker --task_index=0
+
+lsof -i -P -n | grep LISTEN | grep python
+
+
+
+python3 example_train_transe_d.py --job_name "ps" --task_index 0 &
+python3 example_train_transe_d.py --job_name "worker" --task_index 0 &
+
+
+python3 example_train_transe_d.py --ps_hosts=localhost:2222,localhost:2223 --worker_hosts=localhost:2224,localhost:2225 --job_name=ps --task_index=0 &
+python3 example_train_transe_d.py --ps_hosts=localhost:2222,localhost:2223 --worker_hosts=localhost:2224,localhost:2225 --job_name=ps --task_index=1 &
+python3 example_train_transe_d.py --ps_hosts=localhost:2222,localhost:2223 --worker_hosts=localhost:2224,localhost:2225 --job_name=worker --task_index=0 &
+python3 example_train_transe_d.py --ps_hosts=localhost:2222,localhost:2223 --worker_hosts=localhost:2224,localhost:2225 --job_name=worker --task_index=1 &
+
+
+python3 example_train_transe_d.py --ps_hosts=localhost:2222 --worker_hosts=localhost:2223 --job_name=ps --task_index=0 &
+python3 example_train_transe_d.py --ps_hosts=localhost:2222 --worker_hosts=localhost:2223 --job_name=ps --task_index=1 &
+python3 example_train_transe_d.py --ps_hosts=localhost:2222 --worker_hosts=localhost:2223 --job_name=worker --task_index=0 &
+python3 example_train_transe_d.py --ps_hosts=localhost:2222 --worker_hosts=localhost:2223 --job_name=worker --task_index=1 &
+
+
+
+python3 example_train_transe_d.py --ps_hosts=localhost:2222 --worker_hosts=localhost:2223 --job_name=ps --task_index=0 &
+python3 example_train_transe_d.py --ps_hosts=localhost:2222 --worker_hosts=localhost:2223 --job_name=worker --task_index=0 &
+
+
+
+${SPARK_HOME}/bin/spark-submit \
+--master ${MASTER} \
+--py-files /home/luigi/IdeaProjects/OpenKE_Spark/example_train_transe_spark.py \
+--conf spark.cores.max=${TOTAL_CORES} \
+--conf spark.task.cpus=${CORES_PER_WORKER} \
+--conf spark.executorEnv.JAVA_HOME="${JAVA_HOME}" \
+/home/luigi/IdeaProjects/OpenKE_Spark/example_train_transe_spark.py \
+--cluster_size ${SPARK_WORKER_INSTANCES}
+
+
+
+
+${SPARK_HOME}/bin/spark-submit \
+--master ${MASTER} \
+--conf spark.cores.max=${TOTAL_CORES} \
+--conf spark.task.cpus=${CORES_PER_WORKER} \
+/home/luigi/IdeaProjects/OpenKE_Spark/example_train_transe_spark.py \
+--cluster_size ${SPARK_EXECUTOR_INSTANCES}
+
+
+
+##################################################################################################################
+
+
+${SPARK_HOME}/sbin/start-master.sh; ${SPARK_HOME}/sbin/start-slave.sh -c ${CORES_PER_WORKER} -m ${MEMORY_PER_WORKER} ${MASTER}
+
+
+${SPARK_HOME}/sbin/stop-slave.sh; ${SPARK_HOME}/sbin/stop-master.sh
+
+#CPU
+${SPARK_HOME}/bin/spark-submit --master ${MASTER} \
+--py-files /home/luigi/IdeaProjects/OpenKE_new_Spark/distribute_training.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/Config.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/TransE.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/TransH.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/TransR.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/TransD.py \
+--conf spark.dynamicAllocation.enabled=false \
+--conf spark.cores.max=${TOTAL_CORES} --conf spark.task.cpus=${CORES_PER_WORKER} --executor-memory ${MEMORY_PER_WORKER} \
+--num-executors ${SPARK_WORKER_INSTANCES} \
+/home/luigi/IdeaProjects/OpenKE_new_Spark/main_spark.py \
+--cluster_size ${SPARK_WORKER_INSTANCES} --num_ps 1 \
+--input_path /home/luigi/IdeaProjects/OpenKE_new_Spark/benchmarks/DBpedia/5/0/ \
+--output_path /home/luigi/IdeaProjects/OpenKE_new_Spark/res_spark \
+--alpha 0.0001 --optimizer SGD --train_times 50 --ent_neg_rate 1 --embedding_dimension 64 --margin 1.0 --model TransE
+
+
+
+${SPARK_HOME}/bin/spark-submit --master ${MASTER} \
+--py-files /home/luigi/IdeaProjects/OpenKE_new_Spark/distribute_training.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/Config.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/TransE.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/TransH.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/TransR.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/TransD.py \
+--conf spark.cores.max=${TOTAL_CORES} --conf spark.task.cpus=${CORES_PER_WORKER} --executor-memory ${MEMORY_PER_WORKER} \
+--num-executors ${SPARK_WORKER_INSTANCES} \
+/home/luigi/IdeaProjects/OpenKE_new_Spark/main_spark.py \
+--cluster_size ${SPARK_WORKER_INSTANCES} --num_ps 1 \
+--input_path /home/luigi/IdeaProjects/OpenKE_new_Spark/benchmarks/superuser_1/5/ \
+--output_path /home/luigi/IdeaProjects/OpenKE_new_Spark/res_spark \
+--early_stop_patience 10 --early_stop_tolerance 0 \
+--working_threads 8 --alpha 0.0001 --optimizer Adam --train_times 50 --ent_neg_rate 5 --embedding_dimension 64 --margin 1.0 --model TransE
+
+
+#GPU
+${SPARK_HOME}/bin/spark-submit \
+--master ${MASTER} \
+--py-files /home/luigi/IdeaProjects/OpenKE_new_Spark/distribute_training.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/Config.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/TransE.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/TransH.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/TransR.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_new_Spark/TransD.py \
+--conf spark.executorEnv.LD_LIBRARY_PATH=${LIB_CUDA} \
+--driver-library-path=${LIB_CUDA} \
+--num-executors ${SPARK_WORKER_INSTANCES} \
+/home/luigi/IdeaProjects/OpenKE_new_Spark/main_spark.py \
+--cluster_size ${SPARK_WORKER_INSTANCES} \
+--num_ps 1 \
+--input_path /home/luigi/IdeaProjects/OpenKE_new_Spark/benchmarks/superuser_1/5/ \
+--output_path /home/luigi/IdeaProjects/OpenKE_new_Spark/res_spark \
+--working_threads 8 \
+--alpha 0.0001 \
+--early_stop_patience 10 --early_stop_tolerance 0 --optimizer Adam \
+--train_times 200 --ent_neg_rate 5 --embedding_dimension 64 --margin 1.0 --model TransE
+
+
+
+
+--conf spark.driver.memory ${MEMORY_PER_WORKER} \
+--conf spark.executor.memory ${TOTAL_MEMORY} \
+
+
+
+
+${SPARK_HOME}/bin/spark-submit \
+--master ${MASTER} \
+--py-files /home/luigi/IdeaProjects/OpenKE_Spark/distribute_training.py,/home/luigi/IdeaProjects/OpenKE_Spark/Config.py,/home/luigi/IdeaProjects/OpenKE_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_Spark/TransE.py,/home/luigi/IdeaProjects/OpenKE_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_Spark/TransH.py,/home/luigi/IdeaProjects/OpenKE_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_Spark/TransR.py,/home/luigi/IdeaProjects/OpenKE_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_Spark/TransD.py \
+--conf spark.cores.max=${TOTAL_CORES} \
+--conf spark.task.cpus=${CORES_PER_WORKER} \
+--num-executors ${SPARK_WORKER_INSTANCES} \
+/home/luigi/IdeaProjects/OpenKE_Spark/main_spark.py \
+--cluster_size ${SPARK_WORKER_INSTANCES} \
+--num_ps 1 \
+--input_path /home/luigi/IdeaProjects/OpenKE_Spark/benchmarks/superuser/ \
+--output_path /home/luigi/IdeaProjects/OpenKE_Spark/res_spark \
+--working_threads 8 \
+--train_times 100 --n_batches 100 \
+--alpha 0.0001 --margin 1.0 --embedding_dimension 100 \
+--ent_neg_rate 10 --rel_neg_rate 0 --optimizer Adam --model TransE
+
+
+
+
+
+${SPARK_HOME}/sbin/stop-slave.sh; ${SPARK_HOME}/sbin/stop-master.sh
+
+
+##################################################################################################################
+
+
+
+${SPARK_HOME}/bin/spark-submit \
+--master ${MASTER} \
+--num-executors 2 \
+--queue default \
+--py-files /home/luigi/IdeaProjects/OpenKE_Spark/example_train_transe_spark.py,/home/luigi/IdeaProjects/OpenKE_Spark/Config.py,/home/luigi/IdeaProjects/OpenKE_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_Spark/TransE.py \
+--conf spark.cores.max=${TOTAL_CORES} \
+--conf spark.task.cpus=${CORES_PER_WORKER} \
+/home/luigi/IdeaProjects/OpenKE_Spark/main_spark.py \
+--cluster_size ${SPARK_WORKER_INSTANCES} \
+--num_ps 1
+
+
+
+
+
+
+
+
+
+${SPARK_HOME}/bin/spark-submit \
+--master ${MASTER} \
+--py-files /home/luigi/IdeaProjects/OpenKE_Spark/example_train_transe_spark.py,/home/luigi/IdeaProjects/OpenKE_Spark/Config.py,/home/luigi/IdeaProjects/OpenKE_Spark/Model.py,/home/luigi/IdeaProjects/OpenKE_Spark/TransE.py \
+--conf spark.cores.max=${TOTAL_CORES} \
+--conf spark.task.cpus=${CORES_PER_WORKER} \
+--conf spark.executorEnv.JAVA_HOME="$JAVA_HOME" \
+--conf spark.task.maxFailures=1 \
+--conf spark.stage.maxConsecutiveAttempts=1 \
+--executor-cores 1 \
+--num-executors ${SPARK_WORKER_INSTANCES} \
+/home/luigi/IdeaProjects/OpenKE_Spark/main_spark.py \
+--cluster_size ${SPARK_WORKER_INSTANCES} \
+--num_ps 1
+
+
+
+
+
+ \
+--images examples/mnist/csv/train/images \
+--labels examples/mnist/csv/train/labels \
+--format csv \
+--mode train \
+--model mnist_model
+
+
+
+JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/jre
+export PYSPARK_PYTHON=/usr/bin/python3 
+
+
+
+ echo 0 | sudo tee /sys/devices/system/cpu/cpu1/online
+ echo 0 | sudo tee /sys/devices/system/cpu/cpu2/online
+ echo 0 | sudo tee /sys/devices/system/cpu/cpu3/online
+ echo 0 | sudo tee /sys/devices/system/cpu/cpu4/online
+ echo 0 | sudo tee /sys/devices/system/cpu/cpu5/online
+ echo 0 | sudo tee /sys/devices/system/cpu/cpu6/online
+ echo 0 | sudo tee /sys/devices/system/cpu/cpu7/online
+
+
+ echo 1 | sudo tee /sys/devices/system/cpu/cpu1/online
+ echo 1 | sudo tee /sys/devices/system/cpu/cpu2/online
+ echo 1 | sudo tee /sys/devices/system/cpu/cpu3/online
+ echo 1 | sudo tee /sys/devices/system/cpu/cpu4/online
+ echo 1 | sudo tee /sys/devices/system/cpu/cpu5/online
+ echo 1 | sudo tee /sys/devices/system/cpu/cpu6/online
+ echo 1 | sudo tee /sys/devices/system/cpu/cpu7/online
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+