diff --git a/.idea/DeepRec.iml b/.idea/DeepRec.iml
index 7c9d48f..61e7919 100644
--- a/.idea/DeepRec.iml
+++ b/.idea/DeepRec.iml
@@ -2,7 +2,7 @@
 <module type="PYTHON_MODULE" version="4">
   <component name="NewModuleRootManager">
     <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
+    <orderEntry type="jdk" jdkName="Python 3.7 (hand_slice_v2) (2)" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
   <component name="TestRunnerService">
diff --git a/.idea/deployment.xml b/.idea/deployment.xml
index b5a36ff..d643e42 100644
--- a/.idea/deployment.xml
+++ b/.idea/deployment.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="PublishConfigData" autoUpload="On explicit save action">
-    <option name="myAutoUpload" value="ON_EXPLICIT_SAVE" />
+  <component name="PublishConfigData" autoUpload="Always">
+    <option name="myAutoUpload" value="ALWAYS" />
   </component>
 </project>
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
index 3999087..7be559d 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -3,5 +3,5 @@
   <component name="JavaScriptSettings">
     <option name="languageLevel" value="ES6" />
   </component>
-  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.6" project-jdk-type="Python SDK" />
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.7 (hand_slice_v2) (2)" project-jdk-type="Python SDK" />
 </project>
\ No newline at end of file
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index c6a1774..42a13c8 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -1,9 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ChangeListManager">
-    <list default="true" id="ae4db37d-fd5d-4e6f-9a3e-9a06f06b55a5" name="Default Changelist" comment="">
-      <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/testSeqRec.py" beforeDir="false" afterPath="$PROJECT_DIR$/test/testSeqRec.py" afterDir="false" />
+    <list default="true" id="ae4db37d-fd5d-4e6f-9a3e-9a06f06b55a5" name="Default Changelist" comment="convert tf version on NeuMF">
+      <change beforePath="$PROJECT_DIR$/models/item_ranking/bprmf.py" beforeDir="false" afterPath="$PROJECT_DIR$/models/item_ranking/bprmf.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/models/item_ranking/cdae.py" beforeDir="false" afterPath="$PROJECT_DIR$/models/item_ranking/cdae.py" afterDir="false" />
     </list>
     <option name="EXCLUDED_CONVERTED_TO_IGNORED" value="true" />
     <option name="SHOW_DIALOG" value="false" />
@@ -14,154 +14,33 @@
   <component name="CoverageDataManager">
     <SUITE FILE_PATH="coverage/DeepRec$testSeqRec.coverage" NAME="testSeqRec Coverage Results" MODIFIED="1555723083809" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/test" />
   </component>
-  <component name="FUSProjectUsageTrigger">
-    <session id="12977338">
-      <usages-collector id="statistics.lifecycle.project">
-        <counts>
-          <entry key="project.open.time.5" value="1" />
-          <entry key="project.opened" value="1" />
-        </counts>
-      </usages-collector>
-      <usages-collector id="statistics.file.extensions.edit">
-        <counts>
-          <entry key="py" value="27" />
-        </counts>
-      </usages-collector>
-      <usages-collector id="statistics.file.types.edit">
-        <counts>
-          <entry key="Python" value="27" />
-        </counts>
-      </usages-collector>
-    </session>
-  </component>
-  <component name="FileEditorManager">
-    <leaf SIDE_TABS_SIZE_LIMIT_KEY="300">
-      <file pinned="false" current-in-tab="false">
-        <entry file="file://$PROJECT_DIR$/models/seq_rec/Caser.py">
-          <provider selected="true" editor-type-id="text-editor">
-            <state relative-caret-position="224">
-              <caret line="8" column="10" selection-start-line="8" selection-start-column="10" selection-end-line="8" selection-end-column="10" />
-            </state>
-          </provider>
-        </entry>
-      </file>
-      <file pinned="false" current-in-tab="false">
-        <entry file="file://$PROJECT_DIR$/models/seq_rec/AttRec.py">
-          <provider selected="true" editor-type-id="text-editor">
-            <state relative-caret-position="252">
-              <caret line="9" column="12" selection-start-line="9" selection-start-column="12" selection-end-line="9" selection-end-column="12" />
-            </state>
-          </provider>
-        </entry>
-      </file>
-      <file pinned="false" current-in-tab="false">
-        <entry file="file://$PROJECT_DIR$/models/seq_rec/gru4rec.py">
-          <provider selected="true" editor-type-id="text-editor" />
-        </entry>
-      </file>
-      <file pinned="false" current-in-tab="false">
-        <entry file="file://$PROJECT_DIR$/utils/evaluation/SeqRecMetrics.py">
-          <provider selected="true" editor-type-id="text-editor" />
-        </entry>
-      </file>
-      <file pinned="false" current-in-tab="true">
-        <entry file="file://$PROJECT_DIR$/test/testSeqRec.py">
-          <provider selected="true" editor-type-id="text-editor">
-            <state relative-caret-position="361">
-              <caret line="64" column="45" selection-start-line="64" selection-start-column="45" selection-end-line="64" selection-end-column="45" />
-              <folding>
-                <element signature="e#0#15#0" expanded="true" />
-              </folding>
-            </state>
-          </provider>
-        </entry>
-      </file>
-      <file pinned="false" current-in-tab="false">
-        <entry file="file://$PROJECT_DIR$/models/__init__.py">
-          <provider selected="true" editor-type-id="text-editor" />
-        </entry>
-      </file>
-      <file pinned="false" current-in-tab="false">
-        <entry file="file://$PROJECT_DIR$/models/seq_rec/PRME.py">
-          <provider selected="true" editor-type-id="text-editor">
-            <state relative-caret-position="224">
-              <caret line="8" column="20" selection-start-line="8" selection-start-column="20" selection-end-line="8" selection-end-column="20" />
-            </state>
-          </provider>
-        </entry>
-      </file>
-    </leaf>
-  </component>
   <component name="Git.Settings">
     <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
   </component>
-  <component name="IdeDocumentHistory">
-    <option name="CHANGED_PATHS">
-      <list>
-        <option value="$PROJECT_DIR$/models/seq_rec/AttRec.py" />
-        <option value="$PROJECT_DIR$/models/seq_rec/PRME.py" />
-        <option value="$PROJECT_DIR$/models/seq_rec/Caser.py" />
-        <option value="$PROJECT_DIR$/test/testSeqRec.py" />
-      </list>
-    </option>
-  </component>
-  <component name="JsBuildToolGruntFileManager" detection-done="true" sorting="DEFINITION_ORDER" />
-  <component name="JsBuildToolPackageJson" detection-done="true" sorting="DEFINITION_ORDER" />
-  <component name="JsGulpfileManager">
-    <detection-done>true</detection-done>
-    <sorting>DEFINITION_ORDER</sorting>
-  </component>
-  <component name="ProjectFrameBounds">
-    <option name="x" value="39" />
-    <option name="y" value="23" />
-    <option name="width" value="1401" />
-    <option name="height" value="877" />
-  </component>
-  <component name="ProjectView">
-    <navigator proportions="" version="1">
-      <foldersAlwaysOnTop value="true" />
-    </navigator>
-    <panes>
-      <pane id="Scope" />
-      <pane id="ProjectPane">
-        <subPane>
-          <expand>
-            <path>
-              <item name="DeepRec" type="b2602c69:ProjectViewProjectNode" />
-              <item name="DeepRec" type="462c0819:PsiDirectoryNode" />
-            </path>
-            <path>
-              <item name="DeepRec" type="b2602c69:ProjectViewProjectNode" />
-              <item name="DeepRec" type="462c0819:PsiDirectoryNode" />
-              <item name="models" type="462c0819:PsiDirectoryNode" />
-            </path>
-            <path>
-              <item name="DeepRec" type="b2602c69:ProjectViewProjectNode" />
-              <item name="DeepRec" type="462c0819:PsiDirectoryNode" />
-              <item name="models" type="462c0819:PsiDirectoryNode" />
-              <item name="seq_rec" type="462c0819:PsiDirectoryNode" />
-            </path>
-            <path>
-              <item name="DeepRec" type="b2602c69:ProjectViewProjectNode" />
-              <item name="DeepRec" type="462c0819:PsiDirectoryNode" />
-              <item name="test" type="462c0819:PsiDirectoryNode" />
-            </path>
-            <path>
-              <item name="DeepRec" type="b2602c69:ProjectViewProjectNode" />
-              <item name="DeepRec" type="462c0819:PsiDirectoryNode" />
-              <item name="utils" type="462c0819:PsiDirectoryNode" />
-            </path>
-          </expand>
-          <select />
-        </subPane>
-      </pane>
-    </panes>
+  <component name="GithubProjectSettings">
+    <option name="CREATE_PULL_REQUEST_DEFAULT_BRANCH" value="master" />
+    <option name="CREATE_PULL_REQUEST_DEFAULT_REPO_USER" value="cheungdaven" />
+    <option name="CREATE_PULL_REQUEST_DEFAULT_REPO_NAME" value="DeepRec" />
   </component>
+  <component name="ProjectId" id="1XbVYA5EOsw6xBlmEpOLOgxvRZs" />
   <component name="PropertiesComponent">
-    <property name="WebServerToolWindowFactoryState" value="false" />
+    <property name="TODO_SCOPE" value="All Places" />
+    <property name="WebServerToolWindowFactoryState" value="true" />
+    <property name="WebServerToolWindowPanel.toolwindow.highlight.mappings" value="true" />
+    <property name="WebServerToolWindowPanel.toolwindow.highlight.symlinks" value="true" />
+    <property name="WebServerToolWindowPanel.toolwindow.show.date" value="false" />
+    <property name="WebServerToolWindowPanel.toolwindow.show.permissions" value="false" />
+    <property name="WebServerToolWindowPanel.toolwindow.show.size" value="false" />
     <property name="last_opened_file_path" value="$PROJECT_DIR$" />
+    <property name="node.js.detected.package.eslint" value="true" />
+    <property name="node.js.detected.package.tslint" value="true" />
+    <property name="node.js.path.for.package.eslint" value="project" />
+    <property name="node.js.path.for.package.tslint" value="project" />
+    <property name="node.js.selected.package.eslint" value="(autodetect)" />
+    <property name="node.js.selected.package.tslint" value="(autodetect)" />
     <property name="nodejs_interpreter_path.stuck_in_default_project" value="undefined stuck path" />
     <property name="nodejs_npm_path_reset_for_default_project" value="true" />
+    <property name="settings.editor.selected.configurable" value="web.server" />
   </component>
   <component name="RecentsManager">
     <key name="CopyFile.RECENT_KEYS">
@@ -197,8 +76,8 @@
       <option name="ADD_CONTENT_ROOTS" value="true" />
       <option name="ADD_SOURCE_ROOTS" value="true" />
       <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
-      <option name="SCRIPT_NAME" value="$PROJECT_DIR$/test/testSeqRec.py" />
-      <option name="PARAMETERS" value="" />
+      <option name="SCRIPT_NAME" value="$PROJECT_DIR$/test/test_item_ranking.py" />
+      <option name="PARAMETERS" value="--model=&quot;NeuMF&quot;" />
       <option name="SHOW_COMMAND_LINE" value="false" />
       <option name="EMULATE_TERMINAL" value="false" />
       <option name="MODULE_MODE" value="false" />
@@ -223,85 +102,97 @@
       <option name="presentableId" value="Default" />
       <updated>1555722791285</updated>
       <workItem from="1555722792785" duration="268000" />
+      <workItem from="1581314827022" duration="2926000" />
+      <workItem from="1581321994452" duration="734000" />
+      <workItem from="1581323048834" duration="660000" />
+      <workItem from="1583135944300" duration="2824000" />
+      <workItem from="1584253374849" duration="978000" />
+      <workItem from="1584264811754" duration="6152000" />
+      <workItem from="1584364194784" duration="1000" />
+      <workItem from="1584368854330" duration="6810000" />
+      <workItem from="1584534192487" duration="6387000" />
+      <workItem from="1584622429664" duration="8713000" />
+      <workItem from="1584964610265" duration="30000" />
+      <workItem from="1584964664970" duration="6849000" />
+      <workItem from="1585133553120" duration="3620000" />
+    </task>
+    <task id="LOCAL-00001" summary="convert tensorflow version into 2">
+      <created>1581323248675</created>
+      <option name="number" value="00001" />
+      <option name="presentableId" value="LOCAL-00001" />
+      <option name="project" value="LOCAL" />
+      <updated>1581323248675</updated>
+    </task>
+    <task id="LOCAL-00002" summary="fixed minor bug">
+      <created>1584266835830</created>
+      <option name="number" value="00002" />
+      <option name="presentableId" value="LOCAL-00002" />
+      <option name="project" value="LOCAL" />
+      <updated>1584266835830</updated>
+    </task>
+    <task id="LOCAL-00003" summary="convert tensorflow version on CDAE model">
+      <created>1584622487222</created>
+      <option name="number" value="00003" />
+      <option name="presentableId" value="LOCAL-00003" />
+      <option name="project" value="LOCAL" />
+      <updated>1584622487222</updated>
+    </task>
+    <task id="LOCAL-00004" summary="convert tensorflow version on ICDAE model">
+      <created>1584627318636</created>
+      <option name="number" value="00004" />
+      <option name="presentableId" value="LOCAL-00004" />
+      <option name="project" value="LOCAL" />
+      <updated>1584627318636</updated>
     </task>
+    <task id="LOCAL-00005" summary="Refactor BPRMF, CDAE model code">
+      <created>1584715375252</created>
+      <option name="number" value="00005" />
+      <option name="presentableId" value="LOCAL-00005" />
+      <option name="project" value="LOCAL" />
+      <updated>1584715375252</updated>
+    </task>
+    <task id="LOCAL-00006" summary="Refactor BPRMF, CDAE model code">
+      <created>1585137353893</created>
+      <option name="number" value="00006" />
+      <option name="presentableId" value="LOCAL-00006" />
+      <option name="project" value="LOCAL" />
+      <updated>1585137353893</updated>
+    </task>
+    <option name="localTasksCounter" value="7" />
     <servers />
   </component>
-  <component name="TimeTrackingManager">
-    <option name="totallyTimeSpent" value="268000" />
-  </component>
-  <component name="ToolWindowManager">
-    <frame x="39" y="23" width="1401" height="877" extended-state="6" />
-    <editor active="true" />
-    <layout>
-      <window_info active="true" content_ui="combo" id="Project" order="0" visible="true" weight="0.25386313" />
-      <window_info id="Structure" order="1" side_tool="true" weight="0.25" />
-      <window_info id="Favorites" order="2" 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" />
-      <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" />
-      <window_info anchor="bottom" id="Docker" order="7" show_stripe_button="false" />
-      <window_info anchor="bottom" id="Version Control" order="8" />
-      <window_info anchor="bottom" id="Database Changes" order="9" show_stripe_button="false" />
-      <window_info anchor="bottom" id="Event Log" order="10" side_tool="true" />
-      <window_info anchor="bottom" id="Terminal" order="11" />
-      <window_info anchor="bottom" id="Python Console" order="12" />
-      <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="SciView" order="3" />
-      <window_info anchor="right" id="Database" order="4" />
-    </layout>
-  </component>
   <component name="TypeScriptGeneratedFilesManager">
     <option name="version" value="1" />
   </component>
-  <component name="VcsContentAnnotationSettings">
-    <option name="myLimit" value="2678400000" />
+  <component name="Vcs.Log.Tabs.Properties">
+    <option name="TAB_STATES">
+      <map>
+        <entry key="MAIN">
+          <value>
+            <State>
+              <option name="COLUMN_ORDER" />
+            </State>
+          </value>
+        </entry>
+      </map>
+    </option>
   </component>
-  <component name="editorHistoryManager">
-    <entry file="file://$PROJECT_DIR$/models/seq_rec/Caser.py">
-      <provider selected="true" editor-type-id="text-editor">
-        <state relative-caret-position="224">
-          <caret line="8" column="10" selection-start-line="8" selection-start-column="10" selection-end-line="8" selection-end-column="10" />
-        </state>
-      </provider>
-    </entry>
-    <entry file="file://$PROJECT_DIR$/models/seq_rec/AttRec.py">
-      <provider selected="true" editor-type-id="text-editor">
-        <state relative-caret-position="252">
-          <caret line="9" column="12" selection-start-line="9" selection-start-column="12" selection-end-line="9" selection-end-column="12" />
-        </state>
-      </provider>
-    </entry>
-    <entry file="file://$PROJECT_DIR$/models/seq_rec/gru4rec.py">
-      <provider selected="true" editor-type-id="text-editor" />
-    </entry>
-    <entry file="file://$PROJECT_DIR$/utils/evaluation/SeqRecMetrics.py">
-      <provider selected="true" editor-type-id="text-editor" />
-    </entry>
-    <entry file="file://$PROJECT_DIR$/models/__init__.py">
-      <provider selected="true" editor-type-id="text-editor" />
-    </entry>
-    <entry file="file://$PROJECT_DIR$/models/seq_rec/PRME.py">
-      <provider selected="true" editor-type-id="text-editor">
-        <state relative-caret-position="224">
-          <caret line="8" column="20" selection-start-line="8" selection-start-column="20" selection-end-line="8" selection-end-column="20" />
-        </state>
-      </provider>
-    </entry>
-    <entry file="file://$PROJECT_DIR$/test/testSeqRec.py">
-      <provider selected="true" editor-type-id="text-editor">
-        <state relative-caret-position="361">
-          <caret line="64" column="45" selection-start-line="64" selection-start-column="45" selection-end-line="64" selection-end-column="45" />
-          <folding>
-            <element signature="e#0#15#0" expanded="true" />
-          </folding>
-        </state>
-      </provider>
-    </entry>
+  <component name="VcsManagerConfiguration">
+    <MESSAGE value="convert tensorflow version into 2" />
+    <MESSAGE value="fixed minor bug" />
+    <MESSAGE value="convert tensorflow version on CDAE model" />
+    <MESSAGE value="convert tensorflow version on ICDAE model" />
+    <MESSAGE value="Refactor BPRMF, CDAE model code" />
+    <option name="LAST_COMMIT_MESSAGE" value="Refactor BPRMF, CDAE model code" />
+  </component>
+  <component name="XDebuggerManager">
+    <watches-manager>
+      <configuration name="PythonConfigurationType">
+        <watch expression="self._get_corrupted_input(self.train_data[batch_set_idx, :], self.corruption_level)" language="Python" />
+      </configuration>
+    </watches-manager>
+  </component>
+  <component name="com.intellij.coverage.CoverageDataManagerImpl">
+    <SUITE FILE_PATH="coverage/DeepRec$testSeqRec.coverage" NAME="testSeqRec Coverage Results" MODIFIED="1585137126316" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/test" />
   </component>
 </project>
\ No newline at end of file
diff --git a/models/item_ranking/bprmf.py b/models/item_ranking/bprmf.py
index 168f155..3c1e651 100644
--- a/models/item_ranking/bprmf.py
+++ b/models/item_ranking/bprmf.py
@@ -4,9 +4,11 @@
 the twenty-fifth conference on uncertainty in artificial intelligence. AUAI Press, 2009..
 """
 
-import tensorflow as tf
 import time
-import numpy as np
+
+import tensorflow as tf
+from tensorflow.keras import Input, Model
+from tensorflow.keras.layers import Dense, Lambda
 
 from utils.evaluation.RankingMetrics import *
 
@@ -20,10 +22,18 @@
 __status__ = "Development"
 
 
+class EmbeddingLookup(tf.keras.layers.Layer):
+    def __init__(self, input_embedding, **kwargs):
+        super(EmbeddingLookup, self).__init__(**kwargs)
+        self.input_embedding = input_embedding
+
+    def call(self, inputs):
+        return tf.nn.embedding_lookup(self.input_embedding, inputs)
+
+
 class BPRMF(object):
-    def __init__(self, sess, num_user, num_item, learning_rate=0.001, reg_rate=0.1, epoch=500, batch_size=1024,
+    def __init__(self, num_user, num_item, learning_rate=0.001, reg_rate=0.1, epoch=500, batch_size=1024,
                  verbose=False, t=5, display_step=1000):
-        self.sess = sess
         self.num_user = num_user
         self.num_item = num_item
         self.learning_rate = learning_rate
@@ -37,13 +47,14 @@ def __init__(self, sess, num_user, num_item, learning_rate=0.001, reg_rate=0.1,
         self.user_id = None
         self.item_id = None
         self.neg_item_id = None
-        self.y = None
         self.P = None
         self.Q = None
         self.pred_y = None
         self.pred_y_neg = None
         self.loss = None
-        self.optimizer = None
+        self.loss_estimator = tf.keras.metrics.Mean(name='train_loss')
+        self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)
+        self.model = None
 
         self.test_data = None
         self.user = None
@@ -56,26 +67,25 @@ def __init__(self, sess, num_user, num_item, learning_rate=0.001, reg_rate=0.1,
         print("You are running BPRMF.")
 
     def build_network(self, num_factor=30):
-        self.user_id = tf.placeholder(dtype=tf.int32, shape=[None], name='user_id')
-        self.item_id = tf.placeholder(dtype=tf.int32, shape=[None], name='item_id')
-        self.neg_item_id = tf.placeholder(dtype=tf.int32, shape=[None], name='neg_item_id')
-        self.y = tf.placeholder("float", [None], 'rating')
-
-        self.P = tf.Variable(tf.random_normal([self.num_user, num_factor], stddev=0.01))
-        self.Q = tf.Variable(tf.random_normal([self.num_item, num_factor], stddev=0.01))
+        self.user_id = Input(shape=(1,), dtype=tf.int32, name='user_id')
+        self.item_id = Input(shape=(1,), dtype=tf.int32, name='item_id')
+        self.neg_item_id = Input(shape=(1,), dtype=tf.int32, name='neg_item_id')
 
-        user_latent_factor = tf.nn.embedding_lookup(self.P, self.user_id)
-        item_latent_factor = tf.nn.embedding_lookup(self.Q, self.item_id)
-        neg_item_latent_factor = tf.nn.embedding_lookup(self.Q, self.neg_item_id)
+        self.P = tf.Variable(tf.random.normal([self.num_user, num_factor], stddev=0.01))
+        self.Q = tf.Variable(tf.random.normal([self.num_item, num_factor], stddev=0.01))
 
-        self.pred_y = tf.reduce_sum(tf.multiply(user_latent_factor, item_latent_factor), 1)
-        self.pred_y_neg = tf.reduce_sum(tf.multiply(user_latent_factor, neg_item_latent_factor), 1)
+        user_id = Lambda(lambda x: tf.squeeze(x))(self.user_id)
+        item_id = Lambda(lambda x: tf.squeeze(x))(self.item_id)
+        neg_item_id = Lambda(lambda x: tf.squeeze(x))(self.neg_item_id)
 
-        self.loss = - tf.reduce_sum(
-            tf.log(tf.sigmoid(self.pred_y - self.pred_y_neg))) +\
-            self.reg_rate * (tf.nn.l2_loss(self.P) + tf.nn.l2_loss(self.Q))
+        user_latent_factor = EmbeddingLookup(self.P)(user_id)
+        item_latent_factor = EmbeddingLookup(self.Q)(item_id)
+        neg_item_latent_factor = EmbeddingLookup(self.Q)(neg_item_id)
 
-        self.optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate).minimize(self.loss)
+        pred_y = tf.reduce_sum(tf.multiply(user_latent_factor, item_latent_factor), 1)
+        pred_y_neg = tf.reduce_sum(tf.multiply(user_latent_factor, neg_item_latent_factor), 1)
+        self.model = Model(inputs=[self.user_id, self.item_id, self.neg_item_id],
+                           outputs=[pred_y, pred_y_neg])
 
     def prepare_data(self, train_data, test_data):
         """
@@ -94,6 +104,18 @@ def prepare_data(self, train_data, test_data):
         self.test_users = set([u for u in self.test_data.keys() if len(self.test_data[u]) > 0])
         print("data preparation finished.")
 
+    @tf.function
+    def train_op(self, batch_user, batch_item, batch_item_neg):
+        with tf.GradientTape() as tape:
+            pred_y, pred_y_neg = self.model([batch_user, batch_item, batch_item_neg])
+            #TODO: use tf loss object
+            loss = - tf.reduce_sum(
+                tf.math.log(tf.sigmoid(pred_y - pred_y_neg))) + \
+                   self.reg_rate * (tf.nn.l2_loss(self.P) + tf.nn.l2_loss(self.Q))
+        gradients_of_model = tape.gradient(loss, self.model.trainable_variables)
+        self.optimizer.apply_gradients(zip(gradients_of_model, self.model.trainable_variables))
+        self.loss_estimator(loss)
+
     def train(self):
         idxs = np.random.permutation(self.num_training)  # shuffled ordering
         user_random = list(self.user[idxs])
@@ -107,17 +129,19 @@ def train(self):
         # train
         for i in range(self.total_batch):
             start_time = time.time()
-            batch_user = user_random[i * self.batch_size:(i + 1) * self.batch_size]
+            batch_user = np.array(user_random[i * self.batch_size:(i + 1) * self.batch_size])
             batch_item = item_random[i * self.batch_size:(i + 1) * self.batch_size]
             batch_item_neg = item_random_neg[i * self.batch_size:(i + 1) * self.batch_size]
 
-            _, loss = self.sess.run((self.optimizer, self.loss), feed_dict={self.user_id: batch_user,
-                                                                            self.item_id: batch_item,
-                                                                            self.neg_item_id: batch_item_neg})
+            np_batch_user = np.expand_dims(np.array(batch_user), -1)
+            np_batch_item = np.expand_dims(np.array(batch_item), -1)
+            np_batch_item_neg = np.expand_dims(np.array(batch_item_neg), -1)
+
+            self.train_op(np_batch_user, np_batch_item, np_batch_item_neg)
 
             if i % self.display_step == 0:
                 if self.verbose:
-                    print("Index: %04d; cost= %.9f" % (i + 1, np.mean(loss)))
+                    print("Index: %04d; cost= %.9f" % (i + 1, self.loss_estimator.result()))
                     print("one iteration: %s seconds." % (time.time() - start_time))
 
     def test(self):
@@ -126,9 +150,6 @@ def test(self):
     def execute(self, train_data, test_data):
         self.prepare_data(train_data, test_data)
 
-        init = tf.global_variables_initializer()
-        self.sess.run(init)
-
         for epoch in range(self.epochs):
             self.train()
             if epoch % self.T == 0:
@@ -140,7 +161,11 @@ def save(self, path):
         saver.save(self.sess, path)
 
     def predict(self, user_id, item_id):
-        return self.sess.run([self.pred_y], feed_dict={self.user_id: user_id, self.item_id: item_id})[0]
+        user_id = tf.expand_dims(tf.convert_to_tensor(user_id), -1)
+        item_id = tf.expand_dims(tf.convert_to_tensor(item_id), -1)
+        dummy_neg_id = tf.zeros(item_id.shape, tf.int32)
+        pred_y, pred_y_neg = self.model([user_id, item_id, dummy_neg_id])
+        return pred_y.numpy()
 
     def _get_neg_items(self, data):
         all_items = set(np.arange(self.num_item))
diff --git a/models/item_ranking/cdae.py b/models/item_ranking/cdae.py
index 924c47c..e8bad56 100644
--- a/models/item_ranking/cdae.py
+++ b/models/item_ranking/cdae.py
@@ -4,9 +4,12 @@
 of the Ninth ACM International Conference on Web Search and Data Mining. ACM, 2016.
 """
 
-import tensorflow as tf
 import time
+
 import numpy as np
+import tensorflow as tf
+from tensorflow.keras import Input, Model, regularizers
+from tensorflow.keras.layers import Dense, Add, Flatten, Reshape, Activation, Embedding
 
 from utils.evaluation.RankingMetrics import evaluate
 
@@ -19,11 +22,19 @@
 __email__ = "cheungdaven@gmail.com"
 __status__ = "Development"
 
+# TODO: need to move this into tf2_utils
+class EmbeddingLookup(tf.keras.layers.Layer):
+    def __init__(self, input_embedding, **kwargs):
+        super(EmbeddingLookup, self).__init__(**kwargs)
+        self.input_embedding = input_embedding
+
+    def call(self, inputs):
+        return tf.nn.embedding_lookup(self.input_embedding, inputs)
+
 
 class CDAE(object):
-    def __init__(self, sess, num_user, num_item, learning_rate=0.01, reg_rate=0.01, epoch=500, batch_size=100,
+    def __init__(self, num_user, num_item, learning_rate=0.01, reg_rate=0.01, epoch=500, batch_size=100,
                  verbose=False, t=1, display_step=1000):
-        self.sess = sess
         self.num_user = num_user
         self.num_item = num_item
         self.learning_rate = learning_rate
@@ -33,13 +44,14 @@ def __init__(self, sess, num_user, num_item, learning_rate=0.01, reg_rate=0.01,
         self.verbose = verbose
         self.T = t
         self.display_step = display_step
+        self.loss_estimator = tf.keras.metrics.Mean(name='train_loss')
+        self.loss_object = tf.keras.losses.BinaryCrossentropy()
 
         self.user_id = None
         self.corrupted_rating_matrix = None
         self.rating_matrix = None
         self.corruption_level = None
         self.layer_2 = None
-        self.loss = None
         self.optimizer = None
         self.train_data = None
         self.neg_items = None
@@ -48,31 +60,42 @@ def __init__(self, sess, num_user, num_item, learning_rate=0.01, reg_rate=0.01,
         self.test_data = None
         self.test_users = None
         self.reconstruction = None
+
+        self.optimizer = None
+        self.model = None
         print("You are running CDAE.")
 
     def build_network(self, hidden_neuron=500, corruption_level=0):
-        self.corrupted_rating_matrix = tf.placeholder(dtype=tf.float32, shape=[None, self.num_item])
-        self.rating_matrix = tf.placeholder(dtype=tf.float32, shape=[None, self.num_item])
-        self.user_id = tf.placeholder(dtype=tf.int32, shape=[None])
         self.corruption_level = corruption_level
 
-        _W = tf.Variable(tf.random_normal([self.num_item, hidden_neuron], stddev=0.01))
-        _W_prime = tf.Variable(tf.random_normal([hidden_neuron, self.num_item], stddev=0.01))
-        _V = tf.Variable(tf.random_normal([self.num_user, hidden_neuron], stddev=0.01))
+        corrupted_rating_matrix = Input(shape=(self.num_item,), dtype=tf.float32)
+        user_id = Input(shape=(1,), dtype=tf.int32)
+
+        _V = tf.Variable(tf.random.normal([self.num_user, hidden_neuron], stddev=0.01))
+
+        squeezed_user_id = Flatten()(user_id)
+        # user_latent_factor = EmbeddingLookup(_V)(squeezed_user_id)
+        # user_latent_factor = Reshape((_V.shape[-1],))(user_latent_factor)
+        user_latent_embedding = Embedding(input_dim=self.num_user, output_dim=hidden_neuron,
+                                       embeddings_initializer='normal', input_length=1)
+        user_latent_factor = Flatten()(user_latent_embedding(squeezed_user_id))
 
-        b = tf.Variable(tf.random_normal([hidden_neuron], stddev=0.01))
-        b_prime = tf.Variable(tf.random_normal([self.num_item], stddev=0.01))
-        print(np.shape(tf.matmul(self.corrupted_rating_matrix, _W)))
-        print(np.shape(tf.nn.embedding_lookup(_V, self.user_id)))
-        layer_1 = tf.sigmoid(tf.matmul(self.corrupted_rating_matrix, _W) + tf.nn.embedding_lookup(_V, self.user_id) + b)
-        self.layer_2 = tf.sigmoid(tf.matmul(layer_1, _W_prime) + b_prime)
+        z_vector = Dense(hidden_neuron,
+                         kernel_regularizer=regularizers.l2(self.reg_rate),
+                         bias_regularizer=regularizers.l2(self.reg_rate)
+                         )(corrupted_rating_matrix)
 
-        self.loss = - tf.reduce_sum(
-            self.rating_matrix * tf.log(self.layer_2) + (1 - self.rating_matrix) * tf.log(1 - self.layer_2)) + \
-            self.reg_rate * (tf.nn.l2_loss(_W) + tf.nn.l2_loss(_W_prime) + tf.nn.l2_loss(_V) +
-                             tf.nn.l2_loss(b) + tf.nn.l2_loss(b_prime))
+        z_vector = Add()([z_vector, user_latent_factor])
+        z_vector = Activation(tf.nn.sigmoid)(z_vector)
 
-        self.optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate).minimize(self.loss)
+        recon_vector = Dense(self.num_item, activation='sigmoid',
+                             kernel_regularizer=regularizers.l2(self.reg_rate),
+                             bias_regularizer=regularizers.l2(self.reg_rate)
+                             )(z_vector)
+
+        self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)
+        self.model = Model(inputs=[corrupted_rating_matrix, user_id],
+                           outputs=recon_vector)
 
     def prepare_data(self, train_data, test_data):
         self.train_data = self._data_process(train_data)
@@ -83,6 +106,15 @@ def prepare_data(self, train_data, test_data):
         self.test_users = set([u for u in self.test_data.keys() if len(self.test_data[u]) > 0])
         print("data preparation finished.")
 
+    @tf.function
+    def train_op(self, corrupted_rating_matrix, rating_matrix, user_id):
+        with tf.GradientTape() as tape:
+            recon_vector = self.model([corrupted_rating_matrix, user_id])
+            loss = self.loss_object(rating_matrix, recon_vector)
+        gradient_of_model = tape.gradient(loss, self.model.trainable_variables)
+        self.optimizer.apply_gradients(zip(gradient_of_model, self.model.trainable_variables))
+        self.loss_estimator(loss)
+
     def train(self):
         idxs = np.random.permutation(self.num_training)  # shuffled ordering
 
@@ -93,27 +125,25 @@ def train(self):
             elif i < self.total_batch - 1:
                 batch_set_idx = idxs[i * self.batch_size: (i + 1) * self.batch_size]
 
-            _, loss = self.sess.run([self.optimizer, self.loss], feed_dict={
-                self.corrupted_rating_matrix: self._get_corrupted_input(self.train_data[batch_set_idx, :],
-                                                                        self.corruption_level),
-                self.rating_matrix: self.train_data[batch_set_idx, :],
-                self.user_id: batch_set_idx
-                })
+            expanded_batch_set_idx = np.expand_dims(np.array(batch_set_idx), -1)
+            self.train_op(
+                self._get_corrupted_input(self.train_data[batch_set_idx, :], self.corruption_level),
+                np.array(self.train_data[batch_set_idx, :], np.float32),
+                expanded_batch_set_idx)
+
             if self.verbose and i % self.display_step == 0:
-                print("Index: %04d; cost= %.9f" % (i + 1, np.mean(loss)))
+                print("Index: %04d; cost= %.9f" % (i + 1, self.loss_estimator.result()))
                 if self.verbose:
                     print("one iteration: %s seconds." % (time.time() - start_time))
 
     def test(self):
-        self.reconstruction = self.sess.run(self.layer_2, feed_dict={self.corrupted_rating_matrix: self.train_data,
-                                                                     self.user_id: range(self.num_user)})
-
+        reconstruction = self.model([self.train_data, self.train_data, np.expand_dims(range(self.num_user), -1)])
+        self.reconstruction = np.array(reconstruction)
         evaluate(self)
 
     def execute(self, train_data, test_data):
         self.prepare_data(train_data, test_data)
-        init = tf.global_variables_initializer()
-        self.sess.run(init)
+
         for epoch in range(self.epochs):
             self.train()
             if epoch % self.T == 0:
@@ -121,8 +151,7 @@ def execute(self, train_data, test_data):
                 self.test()
 
     def save(self, path):
-        saver = tf.train.Saver()
-        saver.save(self.sess, path)
+        tf.saved_model.save(self.model, path)
 
     def predict(self, user_id, item_id):
         return np.array(self.reconstruction[np.array(user_id), np.array(item_id)])
@@ -141,7 +170,7 @@ def _get_neg_items(self, data):
 
     @staticmethod
     def _get_corrupted_input(input_train_data, corruption_level):
-        return np.random.binomial(n=1, p=1 - corruption_level) * input_train_data
+        return np.array(np.random.binomial(n=1, p=1 - corruption_level) * input_train_data)
 
 
 class ICDAE(object):
@@ -149,9 +178,9 @@ class ICDAE(object):
     Based on CDAE and I-AutoRec, I designed the following item based CDAE, it seems to perform better than CDAE
     slightly.
     """
-    def __init__(self, sess, num_user, num_item, learning_rate=0.01, reg_rate=0.01, epoch=500, batch_size=300,
+
+    def __init__(self, num_user, num_item, learning_rate=0.01, reg_rate=0.01, epoch=500, batch_size=300,
                  verbose=False, t=2, display_step=1000):
-        self.sess = sess
         self.num_user = num_user
         self.num_item = num_item
         self.learning_rate = learning_rate
@@ -161,13 +190,13 @@ def __init__(self, sess, num_user, num_item, learning_rate=0.01, reg_rate=0.01,
         self.verbose = verbose
         self.T = t
         self.display_step = display_step
+        self.loss_estimator = tf.keras.metrics.Mean(name='train_loss')
+        self.loss_object = tf.keras.losses.BinaryCrossentropy()
 
         self.corrupted_interact_matrix = None
         self.interact_matrix = None
-        self.item_id = None
         self.corruption_level = None
         self.layer_2 = None
-        self.loss = None
         self.optimizer = None
         self.train_data = None
         self.neg_items = None
@@ -176,31 +205,31 @@ def __init__(self, sess, num_user, num_item, learning_rate=0.01, reg_rate=0.01,
         self.test_data = None
         self.test_users = None
         self.reconstruction = None
+
+        self.optimizer = None
+        self.model = None
         print("Item based CDAE.")
 
     def build_network(self, hidden_neuron=500, corruption_level=0):
-        self.corrupted_interact_matrix = tf.placeholder(dtype=tf.float32, shape=[None, self.num_user])
-        self.interact_matrix = tf.placeholder(dtype=tf.float32, shape=[None, self.num_user])
-        self.item_id = tf.placeholder(dtype=tf.int32, shape=[None])
+        # self.corrupted_interact_matrix = tf.placeholder(dtype=tf.float32, shape=[None, self.num_user])
+        # self.interact_matrix = tf.placeholder(dtype=tf.float32, shape=[None, self.num_user])
+        # self.item_id = tf.placeholder(dtype=tf.int32, shape=[None])
         self.corruption_level = corruption_level
+        corrupted_rating_matrix = Input(shape=(self.num_user,), dtype=tf.float32)
+        _V = tf.Variable(tf.random.normal([self.num_item, hidden_neuron], stddev=0.01))
 
-        _W = tf.Variable(tf.random_normal([self.num_user, hidden_neuron], stddev=0.01))
-        _W_prime = tf.Variable(tf.random_normal([hidden_neuron, self.num_user], stddev=0.01))
-        _V = tf.Variable(tf.random_normal([self.num_item, hidden_neuron], stddev=0.01))
+        z_vector = Dense(hidden_neuron,
+                         activation='sigmoid',
+                         kernel_regularizer=regularizers.l2(self.reg_rate),
+                         bias_regularizer=regularizers.l2(self.reg_rate))(corrupted_rating_matrix)
 
-        b = tf.Variable(tf.random_normal([hidden_neuron], stddev=0.01))
-        b_prime = tf.Variable(tf.random_normal([self.num_user], stddev=0.01))
-        # print(np.shape(tf.matmul(self.corrupted_interact_matrix, _W)))
-        # print(np.shape( tf.nn.embedding_lookup(_V, self.item_id)))
-        layer_1 = tf.sigmoid(tf.matmul(self.corrupted_interact_matrix, _W) + b)
-        self.layer_2 = tf.sigmoid(tf.matmul(layer_1, _W_prime) + b_prime)
+        recon_vector = Dense(self.num_user, activation='sigmoid',
+                             kernel_regularizer=regularizers.l2(self.reg_rate),
+                             bias_regularizer=regularizers.l2(self.reg_rate))(z_vector)
 
-        self.loss = - tf.reduce_sum(
-            self.interact_matrix * tf.log(self.layer_2) + (1 - self.interact_matrix) * tf.log(1 - self.layer_2)) + \
-            self.reg_rate * (tf.nn.l2_loss(_W) + tf.nn.l2_loss(_W_prime) +
-                             tf.nn.l2_loss(b) + tf.nn.l2_loss(b_prime))
-
-        self.optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate).minimize(self.loss)
+        self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)
+        self.model = Model(inputs=corrupted_rating_matrix,
+                           outputs=recon_vector)
 
     def prepare_data(self, train_data, test_data):
         self.train_data = self._data_process(train_data).transpose()
@@ -211,6 +240,15 @@ def prepare_data(self, train_data, test_data):
         self.test_users = set([u for u in self.test_data.keys() if len(self.test_data[u]) > 0])
         print("data preparation finished.")
 
+    @tf.function
+    def train_op(self, corrupted_rating_matrix, rating_matrix):
+        with tf.GradientTape() as tape:
+            recon_vector = self.model([corrupted_rating_matrix])
+            loss = self.loss_object(rating_matrix, recon_vector)
+        gradient_of_model = tape.gradient(loss, self.model.trainable_variables)
+        self.optimizer.apply_gradients(zip(gradient_of_model, self.model.trainable_variables))
+        self.loss_estimator(loss)
+
     def train(self):
         idxs = np.random.permutation(self.num_training)  # shuffled ordering
 
@@ -221,27 +259,24 @@ def train(self):
             elif i < self.total_batch - 1:
                 batch_set_idx = idxs[i * self.batch_size: (i + 1) * self.batch_size]
 
-            _, loss = self.sess.run([self.optimizer, self.loss], feed_dict={
-                self.corrupted_interact_matrix: self._get_corrupted_input(self.train_data[batch_set_idx, :],
-                                                                          self.corruption_level),
-                self.interact_matrix: self.train_data[batch_set_idx, :],
-                self.item_id: batch_set_idx
-                })
+            self.train_op(
+                self._get_corrupted_input(np.array(self.train_data[batch_set_idx, :], dtype=np.float32), self.corruption_level),
+                np.array(self.train_data[batch_set_idx, :], np.float32)
+                )
+
             if self.verbose and i % self.display_step == 0:
-                print("Index: %04d; cost= %.9f" % (i + 1, np.mean(loss)))
+                print("Index: %04d; cost= %.9f" % (i + 1, self.loss_estimator.result()))
                 if self.verbose:
                     print("one iteration: %s seconds." % (time.time() - start_time))
 
     def test(self):
-        self.reconstruction = self.sess.run(self.layer_2, feed_dict={self.corrupted_interact_matrix: self.train_data,
-                                                                     self.item_id: range(self.num_item)}).transpose()
-
+        reconstruction = self.model([self.train_data, self.train_data])
+        self.reconstruction = np.array(reconstruction)
         evaluate(self)
 
     def execute(self, train_data, test_data):
         self.prepare_data(train_data, test_data)
-        init = tf.global_variables_initializer()
-        self.sess.run(init)
+
         for epoch in range(self.epochs):
             self.train()
             if epoch % self.T == 0:
@@ -249,11 +284,10 @@ def execute(self, train_data, test_data):
                 self.test()
 
     def save(self, path):
-        saver = tf.train.Saver()
-        saver.save(self.sess, path)
+        tf.saved_model.save(self.model, path)
 
     def predict(self, user_id, item_id):
-        return np.array(self.reconstruction[np.array(user_id), np.array(item_id)])
+        return np.array(self.reconstruction[np.array(item_id), np.array(user_id)])
 
     @staticmethod
     def _data_process(data):
diff --git a/models/item_ranking/neumf.py b/models/item_ranking/neumf.py
index f8fa587..e0ad823 100644
--- a/models/item_ranking/neumf.py
+++ b/models/item_ranking/neumf.py
@@ -5,8 +5,9 @@
 """
 
 import tensorflow as tf
+from tensorflow.keras import Input, regularizers, Model
+from tensorflow.keras.layers import Flatten, Embedding, Multiply, concatenate, Dense, Lambda
 import time
-import numpy as np
 import random
 
 from utils.evaluation.RankingMetrics import *
@@ -22,9 +23,8 @@
 
 
 class NeuMF(object):
-    def __init__(self, sess, num_user, num_item, learning_rate=0.5, reg_rate=0.01, epoch=500, batch_size=256,
+    def __init__(self, num_user, num_item, learning_rate=0.5, reg_rate=0.01, epoch=500, batch_size=256,
                  verbose=False, t=1, display_step=1000):
-        self.sess = sess
         self.num_user = num_user
         self.num_item = num_item
         self.learning_rate = learning_rate
@@ -44,7 +44,8 @@ def __init__(self, sess, num_user, num_item, learning_rate=0.5, reg_rate=0.01, e
         self.mlp_P = None
         self.mlp_Q = None
         self.pred_y = None
-        self.loss = None
+        self.loss_estimator = tf.keras.metrics.Mean(name='train_loss')
+        self.loss_object = tf.keras.losses.BinaryCrossentropy()
         self.optimizer = None
 
         self.test_data = None
@@ -60,75 +61,59 @@ def __init__(self, sess, num_user, num_item, learning_rate=0.5, reg_rate=0.01, e
 
     def build_network(self, num_factor=10, num_factor_mlp=64, hidden_dimension=10, num_neg_sample=30):
         self.num_neg_sample = num_neg_sample
-        self.user_id = tf.placeholder(dtype=tf.int32, shape=[None], name='user_id')
-        self.item_id = tf.placeholder(dtype=tf.int32, shape=[None], name='item_id')
-        self.y = tf.placeholder(dtype=tf.float32, shape=[None], name='y')
-
-        self.P = tf.Variable(tf.random_normal([self.num_user, num_factor]), dtype=tf.float32)
-        self.Q = tf.Variable(tf.random_normal([self.num_item, num_factor]), dtype=tf.float32)
-
-        self.mlp_P = tf.Variable(tf.random_normal([self.num_user, num_factor_mlp]), dtype=tf.float32)
-        self.mlp_Q = tf.Variable(tf.random_normal([self.num_item, num_factor_mlp]), dtype=tf.float32)
-
-        user_latent_factor = tf.nn.embedding_lookup(self.P, self.user_id)
-        item_latent_factor = tf.nn.embedding_lookup(self.Q, self.item_id)
-        mlp_user_latent_factor = tf.nn.embedding_lookup(self.mlp_P, self.user_id)
-        mlp_item_latent_factor = tf.nn.embedding_lookup(self.mlp_Q, self.item_id)
-
-        _GMF = tf.multiply(user_latent_factor, item_latent_factor)
-
-        layer_1 = tf.layers.dense(
-            inputs=tf.concat([mlp_item_latent_factor, mlp_user_latent_factor], axis=1),
-            units=num_factor_mlp * 2,
-            kernel_initializer=tf.random_normal_initializer,
-            activation=tf.nn.relu,
-            kernel_regularizer=tf.contrib.layers.l2_regularizer(scale=self.reg_rate))
-
-        layer_2 = tf.layers.dense(
-            inputs=layer_1,
-            units=hidden_dimension * 8,
-            activation=tf.nn.relu,
-            kernel_initializer=tf.random_normal_initializer,
-            kernel_regularizer=tf.contrib.layers.l2_regularizer(scale=self.reg_rate))
-
-        layer_3 = tf.layers.dense(
-            inputs=layer_2,
-            units=hidden_dimension * 4,
-            activation=tf.nn.relu,
-            kernel_initializer=tf.random_normal_initializer,
-            kernel_regularizer=tf.contrib.layers.l2_regularizer(scale=self.reg_rate))
-
-        layer_4 = tf.layers.dense(
-            inputs=layer_3,
-            units=hidden_dimension * 2,
-            activation=tf.nn.relu,
-            kernel_initializer=tf.random_normal_initializer,
-            kernel_regularizer=tf.contrib.layers.l2_regularizer(scale=self.reg_rate))
-
-        _MLP = tf.layers.dense(
-                inputs=layer_4,
-                units=hidden_dimension,
-                activation=tf.nn.relu,
-                kernel_initializer=tf.random_normal_initializer,
-                kernel_regularizer=tf.contrib.layers.l2_regularizer(scale=self.reg_rate))
-
-        self.pred_y = tf.nn.sigmoid(tf.reduce_sum(tf.concat([_GMF, _MLP], axis=1), 1))
-
-        # self.pred_y = tf.layers.dense(
-        #     inputs=tf.concat([_GMF, _MLP], axis=1), units=1, activation=tf.sigmoid,
-        #     kernel_initializer=tf.random_normal_initializer,
-        #     kernel_regularizer= tf.contrib.layers.l2_regularizer(scale=self.reg_rate))
-
-        # -{y.log(p{y=1}) + (1-y).log(1 - p{y=1})} + {regularization loss...}
-        self.loss = - tf.reduce_sum(
-            self.y * tf.log(self.pred_y + 1e-10) + (1 - self.y) * tf.log(1 - self.pred_y + 1e-10)) + \
-            tf.losses.get_regularization_loss() + \
-            self.reg_rate * (tf.nn.l2_loss(self.P) + tf.nn.l2_loss(self.Q) +
-                             tf.nn.l2_loss(self.mlp_P) + tf.nn.l2_loss(self.mlp_Q))
-
-        self.optimizer = tf.train.AdagradOptimizer(self.learning_rate).minimize(self.loss)
+        user_id = Input(shape=(1,), dtype=tf.int32, name='user_id')
+        item_id = Input(shape=(1,), dtype=tf.int32, name='item_id')
 
-        return self
+        P = Embedding(input_dim=self.num_user, output_dim=num_factor, name='mf_embedding_user',
+                                      embeddings_initializer='normal', input_length=1)
+        Q = Embedding(input_dim=self.num_item, output_dim=num_factor, name='mf_embedding_item',
+                                      embeddings_initializer='normal', input_length=1)
+
+        mlp_P = Embedding(input_dim=self.num_user, output_dim=num_factor_mlp, name="mlp_embedding_user",
+                                       embeddings_initializer='normal', input_length=1)
+        mlp_Q = Embedding(input_dim=self.num_item, output_dim=num_factor_mlp, name='mlp_embedding_item',
+                                       embeddings_initializer='normal', input_length=1)
+
+        flatten_user_id = Flatten()(user_id)
+        flatten_item_id = Flatten()(item_id)
+
+        user_latent_factor = Flatten()(P(flatten_user_id))
+        item_latent_factor = Flatten()(Q(flatten_item_id))
+
+        mlp_user_latent_factor = Flatten()(mlp_P(flatten_user_id))
+        mlp_item_latent_factor = Flatten()(mlp_Q(flatten_item_id))
+
+        _GMF = Multiply()([user_latent_factor, item_latent_factor])
+
+        layer_1 = concatenate([mlp_item_latent_factor, mlp_user_latent_factor])
+        layer_1 = Dense(num_factor_mlp, activation='relu',
+                        kernel_regularizer=regularizers.l2(self.reg_rate)
+                        )(layer_1)
+
+        layer_2 = Dense(hidden_dimension * 8, activation='relu',
+                        kernel_regularizer=regularizers.l2(self.reg_rate)
+                        )(layer_1)
+
+        layer_3 = Dense(hidden_dimension * 4,
+                        activation='relu',
+                        kernel_regularizer=regularizers.l2(self.reg_rate)
+                        )(layer_2)
+
+        layer_4 = Dense(hidden_dimension * 2,
+                        activation='relu',
+                        kernel_regularizer=regularizers.l2(self.reg_rate)
+                        )(layer_3)
+
+        _MLP = Dense(hidden_dimension,
+                     activation='relu',
+                     kernel_regularizer=regularizers.l2(self.reg_rate)
+                     )(layer_4)
+
+        pred_y = Dense(1, activation='sigmoid')(concatenate([_GMF, _MLP]))
+        self.model = Model(inputs=[user_id, item_id],
+                            outputs=pred_y)
+
+        self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)
 
     def prepare_data(self, train_data, test_data):
         """
@@ -150,6 +135,15 @@ def prepare_data(self, train_data, test_data):
         print("data preparation finished.")
         return self
 
+    @tf.function
+    def train_op(self, batch_user, batch_item, batch_label):
+        with tf.GradientTape() as tape:
+            pred_y = self.model([batch_user, batch_item])
+            loss = self.loss_object(batch_label, pred_y)
+        gradient_of_model = tape.gradient(loss, self.model.trainable_variables)
+        self.optimizer.apply_gradients(zip(gradient_of_model, self.model.trainable_variables))
+        self.loss_estimator(loss)
+
     def train(self):
         item_temp = self.item[:]
         user_temp = self.user[:]
@@ -172,9 +166,9 @@ def train(self):
         self.total_batch = int(self.num_training / self.batch_size)
         # print(self.total_batch)
         idxs = np.random.permutation(self.num_training)  # shuffled ordering
-        user_random = list(np.array(user_temp)[idxs])
-        item_random = list(np.array(item_temp)[idxs])
-        labels_random = list(np.array(labels_temp)[idxs])
+        user_random = np.array(user_temp)[idxs]
+        item_random = np.array(item_temp)[idxs]
+        labels_random = np.array(labels_temp)[idxs]
 
         # train
         for i in range(self.total_batch):
@@ -183,12 +177,15 @@ def train(self):
             batch_item = item_random[i * self.batch_size:(i + 1) * self.batch_size]
             batch_label = labels_random[i * self.batch_size:(i + 1) * self.batch_size]
 
-            _, loss = self.sess.run((self.optimizer, self.loss),
-                                    feed_dict={self.user_id: batch_user, self.item_id: batch_item, self.y: batch_label})
+            batch_user = np.expand_dims(batch_user, -1)
+            batch_item = np.expand_dims(batch_item, -1)
+            batch_label = np.expand_dims(batch_label, -1)
+
+            self.train_op(batch_user, batch_item, batch_label)
 
             if i % self.display_step == 0:
                 if self.verbose:
-                    print("Index: %04d; cost= %.9f" % (i + 1, np.mean(loss)))
+                    print("Index: %04d; cost= %.9f" % (i + 1, self.loss_estimator.result()))
                     print("one iteration: %s seconds." % (time.time() - start_time))
 
     def test(self):
@@ -197,9 +194,6 @@ def test(self):
     def execute(self, train_data, test_data):
         self.prepare_data(train_data, test_data)
 
-        init = tf.global_variables_initializer()
-        self.sess.run(init)
-
         for epoch in range(self.epochs):
             self.train()
             if epoch % self.T == 0:
@@ -207,11 +201,12 @@ def execute(self, train_data, test_data):
                 self.test()
 
     def save(self, path):
-        saver = tf.train.Saver()
-        saver.save(self.sess, path)
+        tf.saved_model.save(self.model, path)
 
     def predict(self, user_id, item_id):
-        return self.sess.run([self.pred_y], feed_dict={self.user_id: user_id, self.item_id: item_id})[0]
+        user_id = np.expand_dims(np.array(user_id), -1)
+        item_id = np.expand_dims(np.array(item_id), -1)
+        return np.array(self.model([user_id, item_id]))
 
     def _get_neg_items(self, data):
         all_items = set(np.arange(self.num_item))
diff --git a/test/test_item_ranking.py b/test/test_item_ranking.py
index 88f03da..74d9ca5 100644
--- a/test/test_item_ranking.py
+++ b/test/test_item_ranking.py
@@ -5,7 +5,7 @@
 
 sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
 
-from models.item_ranking.cdae import ICDAE
+from models.item_ranking.cdae import ICDAE, CDAE
 from models.item_ranking.bprmf import BPRMF
 from models.item_ranking.cml import CML
 from models.item_ranking.neumf import NeuMF
@@ -41,30 +41,34 @@ def parse_args():
 
     train_data, test_data, n_user, n_item = load_data_neg(test_size=0.2, sep="\t")
 
-    config = tf.ConfigProto()
-    config.gpu_options.allow_growth = True
+    try:
+        gpus = tf.config.experimental.list_physical_devices('GPU')
+        tf.config.experimental.set_memory_growth(gpus[0], True)
+    except:
+        # Invalid device or cannot modify virtual devices once initialized.
+        pass
 
-    with tf.Session(config=config) as sess:
-        model = None
-        # Model selection
-        if args.model == "CDAE":
-            train_data, test_data, n_user, n_item = load_data_all(test_size=0.2, sep="\t")
-            model = ICDAE(sess, n_user, n_item)
-        if args.model == "CML":
-            model = CML(sess, n_user, n_item)
-        if args.model == "LRML":
-            model = LRML(sess, n_user, n_item)
-        if args.model == "BPRMF":
-            model = BPRMF(sess, n_user, n_item)
-        if args.model == "NeuMF":
-            model = NeuMF(sess, n_user, n_item)
-        if args.model == "GMF":
-            model = GMF(sess, n_user, n_item)
-        if args.model == "MLP":
-            model = MLP(sess, n_user, n_item)
-        if args.model == "JRL":
-            model = JRL(sess, n_user, n_item)
-        # build and execute the model
-        if model is not None:
-            model.build_network()
-            model.execute(train_data, test_data)
+    model = None
+    # Model selection
+    if args.model == "CDAE":
+        train_data, test_data, n_user, n_item = load_data_all(test_size=0.2, sep="\t")
+        # model = ICDAE(n_user, n_item)
+        model = CDAE(n_user, n_item)
+    if args.model == "CML":
+        model = CML(n_user, n_item)
+    if args.model == "LRML":
+        model = LRML(n_user, n_item)
+    if args.model == "BPRMF":
+        model = BPRMF(n_user, n_item)
+    if args.model == "NeuMF":
+        model = NeuMF(n_user, n_item)
+    if args.model == "GMF":
+        model = GMF(n_user, n_item)
+    if args.model == "MLP":
+        model = MLP(n_user, n_item)
+    if args.model == "JRL":
+        model = JRL(n_user, n_item)
+    # build and execute the model
+    if model is not None:
+        model.build_network()
+        model.execute(train_data, test_data)