DSSM_keras_preprocess.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "from src.DSSM import dssm_model_keras_preprocess as dssm_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据预处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "FOLDER = \"movielen\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>userId</th>\n",
       "      <th>movieId</th>\n",
       "      <th>rating</th>\n",
       "      <th>timestamp</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3.5</td>\n",
       "      <td>2005-04-02 23:53:47</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>29</td>\n",
       "      <td>3.5</td>\n",
       "      <td>2005-04-02 23:31:16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>32</td>\n",
       "      <td>3.5</td>\n",
       "      <td>2005-04-02 23:33:39</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>47</td>\n",
       "      <td>3.5</td>\n",
       "      <td>2005-04-02 23:32:07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>50</td>\n",
       "      <td>3.5</td>\n",
       "      <td>2005-04-02 23:29:40</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   userId  movieId  rating            timestamp\n",
       "0       1        2     3.5  2005-04-02 23:53:47\n",
       "1       1       29     3.5  2005-04-02 23:31:16\n",
       "2       1       32     3.5  2005-04-02 23:33:39\n",
       "3       1       47     3.5  2005-04-02 23:32:07\n",
       "4       1       50     3.5  2005-04-02 23:29:40"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ratings = pd.read_csv(\n",
    "    os.path.join(FOLDER, 'rating.csv') \n",
    ")\n",
    "\n",
    "ratings.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>movieId</th>\n",
       "      <th>title</th>\n",
       "      <th>genres</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>Adventure|Animation|Children|Comedy|Fantasy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Jumanji (1995)</td>\n",
       "      <td>Adventure|Children|Fantasy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Grumpier Old Men (1995)</td>\n",
       "      <td>Comedy|Romance</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>Waiting to Exhale (1995)</td>\n",
       "      <td>Comedy|Drama|Romance</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>Father of the Bride Part II (1995)</td>\n",
       "      <td>Comedy</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   movieId                               title  \\\n",
       "0        1                    Toy Story (1995)   \n",
       "1        2                      Jumanji (1995)   \n",
       "2        3             Grumpier Old Men (1995)   \n",
       "3        4            Waiting to Exhale (1995)   \n",
       "4        5  Father of the Bride Part II (1995)   \n",
       "\n",
       "                                        genres  \n",
       "0  Adventure|Animation|Children|Comedy|Fantasy  \n",
       "1                   Adventure|Children|Fantasy  \n",
       "2                               Comedy|Romance  \n",
       "3                         Comedy|Drama|Romance  \n",
       "4                                       Comedy  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movies = pd.read_csv(\n",
    "    os.path.join(FOLDER, 'movie.csv')\n",
    ")\n",
    "\n",
    "movies.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### tags"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>movieId</th>\n",
       "      <th>tagId</th>\n",
       "      <th>relevance</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0.02500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0.02500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>0.05775</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>0.09675</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>5</td>\n",
       "      <td>0.14675</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   movieId  tagId  relevance\n",
       "0        1      1    0.02500\n",
       "1        1      2    0.02500\n",
       "2        1      3    0.05775\n",
       "3        1      4    0.09675\n",
       "4        1      5    0.14675"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tags = pd.read_csv(\n",
    "    os.path.join(FOLDER, 'genome_scores.csv')\n",
    ")\n",
    "\n",
    "tags.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_top10(df):\n",
    "    df = df.sort_values(by='relevance', ascending=False).head(10)\n",
    "    tags_group_dict = {}\n",
    "    # tags_group_dict[\"movieId\"].append(movieId)\n",
    "    tags_group_dict[\"tags\"] = df[\"tagId\"].values.tolist()\n",
    "    tags_group_dict[\"relevances\"] = df[\"relevance\"].values.tolist()\n",
    "    return pd.Series(tags_group_dict)\n",
    "tags_group = tags.groupby(\"movieId\").apply(get_top10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>userId</th>\n",
       "      <th>movieId</th>\n",
       "      <th>rating</th>\n",
       "      <th>timestamp</th>\n",
       "      <th>title</th>\n",
       "      <th>genres</th>\n",
       "      <th>tags</th>\n",
       "      <th>relevances</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3.5</td>\n",
       "      <td>2005-04-02 23:53:47</td>\n",
       "      <td>Jumanji (1995)</td>\n",
       "      <td>Adventure|Children|Fantasy</td>\n",
       "      <td>[29, 584, 204, 588, 951, 377, 62, 415, 203, 374]</td>\n",
       "      <td>[0.981, 0.967, 0.96425, 0.9585, 0.93475, 0.934...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>2</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1996-12-25 15:26:09</td>\n",
       "      <td>Jumanji (1995)</td>\n",
       "      <td>Adventure|Children|Fantasy</td>\n",
       "      <td>[29, 584, 204, 588, 951, 377, 62, 415, 203, 374]</td>\n",
       "      <td>[0.981, 0.967, 0.96425, 0.9585, 0.93475, 0.934...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>13</td>\n",
       "      <td>2</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1996-11-27 08:19:02</td>\n",
       "      <td>Jumanji (1995)</td>\n",
       "      <td>Adventure|Children|Fantasy</td>\n",
       "      <td>[29, 584, 204, 588, 951, 377, 62, 415, 203, 374]</td>\n",
       "      <td>[0.981, 0.967, 0.96425, 0.9585, 0.93475, 0.934...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>29</td>\n",
       "      <td>2</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1996-06-23 20:36:14</td>\n",
       "      <td>Jumanji (1995)</td>\n",
       "      <td>Adventure|Children|Fantasy</td>\n",
       "      <td>[29, 584, 204, 588, 951, 377, 62, 415, 203, 374]</td>\n",
       "      <td>[0.981, 0.967, 0.96425, 0.9585, 0.93475, 0.934...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>34</td>\n",
       "      <td>2</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1996-10-28 13:29:44</td>\n",
       "      <td>Jumanji (1995)</td>\n",
       "      <td>Adventure|Children|Fantasy</td>\n",
       "      <td>[29, 584, 204, 588, 951, 377, 62, 415, 203, 374]</td>\n",
       "      <td>[0.981, 0.967, 0.96425, 0.9585, 0.93475, 0.934...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   userId  movieId  rating            timestamp           title  \\\n",
       "0       1        2     3.5  2005-04-02 23:53:47  Jumanji (1995)   \n",
       "1       5        2     3.0  1996-12-25 15:26:09  Jumanji (1995)   \n",
       "2      13        2     3.0  1996-11-27 08:19:02  Jumanji (1995)   \n",
       "3      29        2     3.0  1996-06-23 20:36:14  Jumanji (1995)   \n",
       "4      34        2     3.0  1996-10-28 13:29:44  Jumanji (1995)   \n",
       "\n",
       "                       genres  \\\n",
       "0  Adventure|Children|Fantasy   \n",
       "1  Adventure|Children|Fantasy   \n",
       "2  Adventure|Children|Fantasy   \n",
       "3  Adventure|Children|Fantasy   \n",
       "4  Adventure|Children|Fantasy   \n",
       "\n",
       "                                               tags  \\\n",
       "0  [29, 584, 204, 588, 951, 377, 62, 415, 203, 374]   \n",
       "1  [29, 584, 204, 588, 951, 377, 62, 415, 203, 374]   \n",
       "2  [29, 584, 204, 588, 951, 377, 62, 415, 203, 374]   \n",
       "3  [29, 584, 204, 588, 951, 377, 62, 415, 203, 374]   \n",
       "4  [29, 584, 204, 588, 951, 377, 62, 415, 203, 374]   \n",
       "\n",
       "                                          relevances  \n",
       "0  [0.981, 0.967, 0.96425, 0.9585, 0.93475, 0.934...  \n",
       "1  [0.981, 0.967, 0.96425, 0.9585, 0.93475, 0.934...  \n",
       "2  [0.981, 0.967, 0.96425, 0.9585, 0.93475, 0.934...  \n",
       "3  [0.981, 0.967, 0.96425, 0.9585, 0.93475, 0.934...  \n",
       "4  [0.981, 0.967, 0.96425, 0.9585, 0.93475, 0.934...  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all = ratings.merge(movies, \"inner\", on=\"movieId\").merge(tags_group, \"inner\", on=\"movieId\")\n",
    "all.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## genres 特征构造"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_genres(genres):\n",
    "    return genres.split(\"|\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "genres_set = set()\n",
    "maxLen = 0\n",
    "for index, row in movies.iterrows():\n",
    "    genres = set(split_genres(row[\"genres\"]))\n",
    "    if len(genres)>maxLen:\n",
    "        maxLen=len(genres)\n",
    "    genres_set|=genres\n",
    "genre_vocabulary_list = list(genres_set)\n",
    "genre_vocabulary_list.append(\"<PAD>\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print(maxLen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## keras preprocess layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "userId_layer = tf.keras.layers.IntegerLookup(\n",
    "     max_tokens = 200000, output_mode='int')\n",
    "\n",
    "user_embedding_layer = tf.keras.layers.Embedding(200000,32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "movie_genre_IDs_layer = tf.keras.layers.StringLookup(\n",
    "    vocabulary=genre_vocabulary_list, num_oov_indices=0)\n",
    "weighted_movie_genre_IDs_layer = tf.keras.layers.CategoryEncoding(num_tokens=len(genre_vocabulary_list)+16, output_mode='count')\n",
    "movie_genre_embedding_layer = tf.keras.layers.Dense(32, use_bias=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maxTags = 1200\n",
    "tag_IDs_layer = tf.keras.layers.IntegerLookup(\n",
    "     max_tokens = maxTags, output_mode='int')\n",
    "weighted_movie_tag_IDs_layer = tf.keras.layers.CategoryEncoding(num_tokens=maxTags+16, output_mode='count')\n",
    "tag_embedding_layer = tf.keras.layers.Dense(32, use_bias=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EPS = 0  #CategoryEncoding可以处理取值为0的情况\n",
    "\n",
    "train_model_input = {}\n",
    "train_model_input[\"userId\"] = all[\"userId\"].values[:, np.newaxis]\n",
    "train_model_input[\"genres\"] = []\n",
    "train_model_input[\"genre_weights\"] = []\n",
    "train_model_input[\"tags\"] = np.array(all[\"tags\"].values.tolist())\n",
    "train_model_input[\"tags_weights\"] = np.array(all[\"relevances\"].values.tolist())\n",
    "\n",
    "for genres_str in all[\"genres\"].values:\n",
    "    genres_list = split_genres(genres_str)\n",
    "    genres_list_len = len(genres_list)\n",
    "    genres_list += [\"<PAD>\"]*(maxLen-genres_list_len)\n",
    "    train_model_input[\"genres\"].append(genres_list)\n",
    "    train_model_input[\"genre_weights\"].append([1]*genres_list_len+[EPS]*(maxLen-genres_list_len))\n",
    "\n",
    "# tf.keras.layers.IntegerLookup需要在加入模型之前adapt初始化，此处是为了程序能够快速执行只adapt前1k个\n",
    "userId_layer.adapt(train_model_input[\"userId\"][:1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tag_IDs_layer.adapt(np.arange(1, maxTags+16))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = {}\n",
    "feature_names = [\n",
    "    \"userId\", \"genres\", \"genre_weights\", \"tags\", \"tags_weights\"\n",
    "]\n",
    "feature_dtypes = [\n",
    "    tf.dtypes.int32, tf.dtypes.string, tf.dtypes.float32, tf.dtypes.int32, tf.dtypes.float32\n",
    "]\n",
    "feature_dimensions = [\n",
    "    1, maxLen, maxLen, 10, 10\n",
    "]\n",
    "\n",
    "for feature_name, feature_dtype, feature_dimension in zip(feature_names, feature_dtypes, feature_dimensions):\n",
    "    inputs[feature_name] = tf.keras.layers.Input(shape=(feature_dimension), name=feature_name, dtype=feature_dtype)\n",
    "\n",
    "user_embedding = user_embedding_layer(userId_layer(inputs[\"userId\"]))\n",
    "genres_embedding = movie_genre_embedding_layer(\\\n",
    "    weighted_movie_genre_IDs_layer(\\\n",
    "        movie_genre_IDs_layer(inputs[\"genres\"]), count_weights=inputs[\"genre_weights\"]))\n",
    "tags_embedding = tag_embedding_layer(\\\n",
    "    weighted_movie_tag_IDs_layer(\\\n",
    "        tag_IDs_layer(inputs[\"tags\"]), count_weights=inputs[\"tags_weights\"]))\n",
    "\n",
    "item_embedding = tf.keras.layers.Concatenate(axis= -1)([genres_embedding, tags_embedding])\n",
    "\n",
    "model = dssm_model(inputs, item_embedding, user_embedding, \n",
    "                   item_hidden_unit=[64, 64],\n",
    "                   user_hidden_units=[],\n",
    "                   output_hidden_units=[128,],\n",
    "                   activation=\"relu\")\n",
    "model.compile(optimizer='adam', loss='mse', metrics=['mse'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " genres (InputLayer)            [(None, 10)]         0           []                               \n",
      "                                                                                                  \n",
      " tags (InputLayer)              [(None, 10)]         0           []                               \n",
      "                                                                                                  \n",
      " string_lookup (StringLookup)   (None, 10)           0           ['genres[0][0]']                 \n",
      "                                                                                                  \n",
      " genre_weights (InputLayer)     [(None, 10)]         0           []                               \n",
      "                                                                                                  \n",
      " integer_lookup_1 (IntegerLooku  (None, 10)          0           ['tags[0][0]']                   \n",
      " p)                                                                                               \n",
      "                                                                                                  \n",
      " tags_weights (InputLayer)      [(None, 10)]         0           []                               \n",
      "                                                                                                  \n",
      " category_encoding (CategoryEnc  (None, 37)          0           ['string_lookup[0][0]',          \n",
      " oding)                                                           'genre_weights[0][0]']          \n",
      "                                                                                                  \n",
      " category_encoding_1 (CategoryE  (None, 1216)        0           ['integer_lookup_1[0][0]',       \n",
      " ncoding)                                                         'tags_weights[0][0]']           \n",
      "                                                                                                  \n",
      " dense (Dense)                  (None, 32)           1184        ['category_encoding[0][0]']      \n",
      "                                                                                                  \n",
      " dense_1 (Dense)                (None, 32)           38912       ['category_encoding_1[0][0]']    \n",
      "                                                                                                  \n",
      " concatenate (Concatenate)      (None, 64)           0           ['dense[0][0]',                  \n",
      "                                                                  'dense_1[0][0]']                \n",
      "                                                                                                  \n",
      " dense_2 (Dense)                (None, 64)           4160        ['concatenate[0][0]']            \n",
      "                                                                                                  \n",
      " userId (InputLayer)            [(None, 1)]          0           []                               \n",
      "                                                                                                  \n",
      " batch_normalization (BatchNorm  (None, 64)          256         ['dense_2[0][0]']                \n",
      " alization)                                                                                       \n",
      "                                                                                                  \n",
      " integer_lookup (IntegerLookup)  (None, 1)           0           ['userId[0][0]']                 \n",
      "                                                                                                  \n",
      " dense_3 (Dense)                (None, 64)           4160        ['batch_normalization[0][0]']    \n",
      "                                                                                                  \n",
      " embedding (Embedding)          (None, 1, 32)        6400000     ['integer_lookup[0][0]']         \n",
      "                                                                                                  \n",
      " batch_normalization_1 (BatchNo  (None, 64)          256         ['dense_3[0][0]']                \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " tf.compat.v1.squeeze (TFOpLamb  (None, 32)          0           ['embedding[0][0]']              \n",
      " da)                                                                                              \n",
      "                                                                                                  \n",
      " concatenate_1 (Concatenate)    (None, 96)           0           ['batch_normalization_1[0][0]',  \n",
      "                                                                  'tf.compat.v1.squeeze[0][0]']   \n",
      "                                                                                                  \n",
      " dense_4 (Dense)                (None, 128)          12416       ['concatenate_1[0][0]']          \n",
      "                                                                                                  \n",
      " batch_normalization_2 (BatchNo  (None, 128)         512         ['dense_4[0][0]']                \n",
      " rmalization)                                                                                     \n",
      "                                                                                                  \n",
      " dense_5 (Dense)                (None, 1)            129         ['batch_normalization_2[0][0]']  \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 6,461,985\n",
      "Trainable params: 6,461,473\n",
      "Non-trainable params: 512\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2/2 [==============================] - 11s 591ms/step - loss: 12.6248 - mse: 12.6248 - val_loss: 15.0276 - val_mse: 15.0276\n"
     ]
    }
   ],
   "source": [
    "#train_model_input作为训练集 rating作为标签值\n",
    "history = model.fit(train_model_input, ratings['rating'].values, batch_size=16, epochs=1, verbose=True, validation_split=0.2 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "dummy_input = {}\n",
    "for key in train_model_input.keys():\n",
    "    dummy_input[key] = tf.constant(train_model_input[key][:32])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 8s 8s/step\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.]], dtype=float32)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.predict(dummy_input)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf2",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.17"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}