= (checkpoint * 1e6)):\n saved_key_checkpoints[j] = True\n save_model(str(checkpoint) + 'M')\n\n save_model()\n\n env.close()\n return mean_rewards\n"}}},{"rowIdx":6,"cells":{"python_code":{"kind":"string","value":"import tensorflow as tf\nfrom mpi4py import MPI\nfrom coinrun.config import Config\nimport numpy as np\n\ndef clean_tb_dir():\n comm = MPI.COMM_WORLD\n rank = comm.Get_rank()\n\n if rank == 0:\n if tf.gfile.Exists(Config.TB_DIR):\n tf.gfile.DeleteRecursively(Config.TB_DIR) \n tf.gfile.MakeDirs(Config.TB_DIR)\n\n comm.Barrier()\n\nclass TB_Writer(object):\n def __init__(self, sess):\n comm = MPI.COMM_WORLD\n rank = comm.Get_rank()\n\n clean_tb_dir()\n\n tb_writer = tf.summary.FileWriter(Config.TB_DIR + '/' + Config.RUN_ID + '_' + str(rank), sess.graph)\n total_steps = [0]\n\n should_log = (rank == 0 or Config.LOG_ALL_MPI)\n\n if should_log:\n hyperparams = np.array(Config.get_arg_text())\n hyperparams_tensor = tf.constant(hyperparams)\n\n summary_op = tf.summary.text(\"hyperparameters info\", hyperparams_tensor)\n summary = sess.run(summary_op)\n\n tb_writer.add_summary(summary)\n\n def add_summary(_merged, interval=1):\n if should_log:\n total_steps[0] += 1\n\n if total_steps[0] % interval == 0:\n tb_writer.add_summary(_merged, total_steps[0])\n tb_writer.flush()\n\n tuples = []\n\n def make_scalar_graph(name):\n scalar_ph = tf.placeholder(name='scalar_' + name, dtype=tf.float32)\n scalar_summary = tf.summary.scalar(name, scalar_ph)\n merged = tf.summary.merge([scalar_summary])\n tuples.append((scalar_ph, merged))\n\n name_dict = {}\n curr_name_idx = [0]\n\n def log_scalar(x, name, step=-1):\n if not name in name_dict:\n name_dict[name] = curr_name_idx[0]\n tf_name = (name + '_' + Config.RUN_ID) if curr_name_idx[0] == 0 else name\n make_scalar_graph(tf_name)\n curr_name_idx[0] += 1\n\n idx = name_dict[name]\n\n scalar_ph, merged = tuples[idx]\n \n if should_log:\n if step == -1:\n step = total_steps[0]\n total_steps[0] += 1\n\n _merged = sess.run(merged, {scalar_ph: x})\n\n tb_writer.add_summary(_merged, step)\n tb_writer.flush()\n \n self.add_summary = add_summary\n self.log_scalar = log_scalar\n"}}},{"rowIdx":7,"cells":{"python_code":{"kind":"string","value":"from .coinrunenv import init_args_and_threads\nfrom .coinrunenv import make\n\n__all__ = [\n 'init_args_and_threads',\n 'make'\n ]\n"}}},{"rowIdx":8,"cells":{"python_code":{"kind":"string","value":"import gym\nimport numpy as np\n\nclass EpsilonGreedyWrapper(gym.Wrapper):\n \"\"\"\n Wrapper to perform a random action each step instead of the requested action, \n with the provided probability.\n \"\"\"\n def __init__(self, env, prob=0.05):\n gym.Wrapper.__init__(self, env)\n self.prob = prob\n self.num_envs = env.num_envs\n\n def reset(self):\n return self.env.reset()\n\n def step(self, action):\n if np.random.uniform() 0\n\n if use_aux:\n for i, info in enumerate(infos):\n self.aux_rewards[i,:] += info['aux_rew']\n self.long_aux_rewards[i,:] += info['aux_rew']\n\n for i, d in enumerate(done):\n if d:\n epinfo = {'r': round(self.rewards[i], 6), 'l': self.lengths[i], 't': 0}\n aux_dict = {}\n\n for nr in range(self.num_aux_rews):\n aux_dict['aux_' + str(nr)] = self.aux_rewards[i,nr]\n\n if 'ale.lives' in infos[i]:\n game_over_rew = np.nan\n\n is_game_over = infos[i]['ale.lives'] == 0\n\n if is_game_over:\n game_over_rew = self.long_aux_rewards[i,0]\n self.long_aux_rewards[i,:] = 0\n\n aux_dict['game_over_rew'] = game_over_rew\n\n epinfo['aux_dict'] = aux_dict\n\n infos[i]['episode'] = epinfo\n\n self.rewards[i] = 0\n self.lengths[i] = 0\n self.aux_rewards[i,:] = 0\n\n return obs, rew, done, infos\n\n self.reset = reset\n self.step = step\n\ndef add_final_wrappers(env):\n env = EpisodeRewardWrapper(env)\n\n return env"}}},{"rowIdx":9,"cells":{"python_code":{"kind":"string","value":"\"\"\"\nRun a CoinRun environment in a window where you can interact with it using the keyboard\n\"\"\"\n\nfrom coinrun.coinrunenv import lib\nfrom coinrun import setup_utils\n\n\ndef main():\n setup_utils.setup_and_load(paint_vel_info=0)\n print(\"\"\"Control with arrow keys,\nF1, F2 -- switch resolution,\nF5, F6, F7, F8 -- zoom,\nF9 -- switch reconstruction target picture,\nF10 -- switch lasers\n \"\"\")\n lib.test_main_loop()\n\n\nif __name__ == '__main__':\n main()"}}},{"rowIdx":10,"cells":{"python_code":{"kind":"string","value":"import tensorflow as tf\nimport os\nimport joblib\nimport numpy as np\n\nfrom mpi4py import MPI\n\nfrom baselines.common.vec_env.vec_frame_stack import VecFrameStack\nfrom coinrun.config import Config\nfrom coinrun import setup_utils, wrappers\n\nimport platform\n\ndef make_general_env(num_env, seed=0, use_sub_proc=True):\n from coinrun import coinrunenv\n \n env = coinrunenv.make(Config.GAME_TYPE, num_env)\n\n if Config.FRAME_STACK > 1:\n env = VecFrameStack(env, Config.FRAME_STACK)\n\n epsilon = Config.EPSILON_GREEDY\n\n if epsilon > 0:\n env = wrappers.EpsilonGreedyWrapper(env, epsilon)\n\n return env\n\ndef file_to_path(filename):\n return setup_utils.file_to_path(filename)\n\ndef load_all_params(sess):\n load_params_for_scope(sess, 'model')\n\ndef load_params_for_scope(sess, scope, load_key='default'):\n load_data = Config.get_load_data(load_key)\n if load_data is None:\n return False\n\n params_dict = load_data['params']\n\n if scope in params_dict:\n print('Loading saved file for scope', scope)\n\n loaded_params = params_dict[scope]\n\n loaded_params, params = get_savable_params(loaded_params, scope, keep_heads=True)\n\n restore_params(sess, loaded_params, params)\n \n return True\n\ndef get_savable_params(loaded_params, scope, keep_heads=False):\n params = tf.trainable_variables(scope)\n filtered_params = []\n filtered_loaded = []\n\n if len(loaded_params) != len(params):\n print('param mismatch', len(loaded_params), len(params))\n assert(False)\n\n for p, loaded_p in zip(params, loaded_params):\n keep = True\n\n if any((scope + '/' + x) in p.name for x in ['v','pi']):\n keep = keep_heads\n\n if keep:\n filtered_params.append(p)\n filtered_loaded.append(loaded_p)\n else:\n print('drop', p)\n \n\n return filtered_loaded, filtered_params\n\ndef restore_params(sess, loaded_params, params):\n if len(loaded_params) != len(params):\n print('param mismatch', len(loaded_params), len(params))\n assert(False)\n\n restores = []\n for p, loaded_p in zip(params, loaded_params):\n print('restoring', p)\n restores.append(p.assign(loaded_p))\n sess.run(restores)\n\ndef save_params_in_scopes(sess, scopes, filename, base_dict=None):\n data_dict = {}\n\n if base_dict is not None:\n data_dict.update(base_dict)\n\n save_path = file_to_path(filename)\n\n data_dict['args'] = Config.get_args_dict()\n param_dict = {}\n\n for scope in scopes:\n params = tf.trainable_variables(scope)\n\n if len(params) > 0:\n print('saving scope', scope, filename)\n ps = sess.run(params)\n\n param_dict[scope] = ps\n \n data_dict['params'] = param_dict\n joblib.dump(data_dict, save_path)\n\ndef setup_mpi_gpus():\n if 'RCALL_NUM_GPU' not in os.environ:\n return\n num_gpus = int(os.environ['RCALL_NUM_GPU'])\n node_id = platform.node()\n nodes = MPI.COMM_WORLD.allgather(node_id)\n local_rank = len([n for n in nodes[:MPI.COMM_WORLD.Get_rank()] if n == node_id])\n os.environ['CUDA_VISIBLE_DEVICES'] = str(local_rank % num_gpus)\n\ndef is_mpi_root():\n return MPI.COMM_WORLD.Get_rank() == 0\n\ndef tf_initialize(sess):\n sess.run(tf.initialize_all_variables())\n sync_from_root(sess)\n \ndef sync_from_root(sess, vars=None):\n if vars is None:\n vars = tf.trainable_variables()\n\n if Config.SYNC_FROM_ROOT:\n rank = MPI.COMM_WORLD.Get_rank()\n print('sync from root', rank)\n for var in vars:\n if rank == 0:\n MPI.COMM_WORLD.bcast(sess.run(var))\n else:\n sess.run(tf.assign(var, MPI.COMM_WORLD.bcast(None)))\n\ndef mpi_average(values):\n return mpi_average_comm(values, MPI.COMM_WORLD)\n\ndef mpi_average_comm(values, comm):\n size = comm.size\n\n x = np.array(values)\n buf = np.zeros_like(x)\n comm.Allreduce(x, buf, op=MPI.SUM)\n buf = buf / size\n\n return buf\n\ndef mpi_average_train_test(values):\n return mpi_average_comm(values, Config.TRAIN_TEST_COMM)\n \ndef mpi_print(*args):\n rank = MPI.COMM_WORLD.Get_rank()\n\n if rank == 0:\n print(*args)\n\ndef process_ep_buf(epinfobuf, tb_writer=None, suffix='', step=0):\n rewards = [epinfo['r'] for epinfo in epinfobuf]\n rew_mean = np.nanmean(rewards)\n\n if Config.SYNC_FROM_ROOT:\n rew_mean = mpi_average_train_test([rew_mean])[0]\n\n if tb_writer is not None:\n tb_writer.log_scalar(rew_mean, 'rew_mean' + suffix, step)\n\n aux_dicts = []\n\n if len(epinfobuf) > 0 and 'aux_dict' in epinfobuf[0]:\n aux_dicts = [epinfo['aux_dict'] for epinfo in epinfobuf]\n\n if len(aux_dicts) > 0:\n keys = aux_dicts[0].keys()\n\n for key in keys:\n sub_rews = [aux_dict[key] for aux_dict in aux_dicts]\n sub_rew = np.nanmean(sub_rews)\n\n if tb_writer is not None:\n tb_writer.log_scalar(sub_rew, key, step)\n\n return rew_mean\n"}}},{"rowIdx":11,"cells":{"python_code":{"kind":"string","value":"from coinrun.config import Config\n\nimport os\nimport joblib\n\ndef load_for_setup_if_necessary():\n restore_file(Config.RESTORE_ID)\n\ndef restore_file(restore_id, load_key='default'):\n if restore_id is not None:\n load_file = Config.get_load_filename(restore_id=restore_id)\n filepath = file_to_path(load_file)\n load_data = joblib.load(filepath)\n\n Config.set_load_data(load_data, load_key=load_key)\n\n restored_args = load_data['args']\n sub_dict = {}\n res_keys = Config.RES_KEYS\n\n for key in res_keys:\n if key in restored_args:\n sub_dict[key] = restored_args[key]\n else:\n print('warning key %s not restored' % key)\n\n Config.parse_args_dict(sub_dict)\n \n from coinrun.coinrunenv import init_args_and_threads\n init_args_and_threads(4)\n\ndef setup_and_load(use_cmd_line_args=True, **kwargs):\n \"\"\"\n Initialize the global config using command line options, defaulting to the values in `config.py`.\n\n `use_cmd_line_args`: set to False to ignore command line arguments passed to the program\n `**kwargs`: override the defaults from `config.py` with these values\n \"\"\"\n args = Config.initialize_args(use_cmd_line_args=use_cmd_line_args, **kwargs)\n\n load_for_setup_if_necessary()\n\n return args\n\ndef file_to_path(filename):\n return os.path.join(Config.WORKDIR, filename)"}}},{"rowIdx":12,"cells":{"python_code":{"kind":"string","value":"from coinrun import random_agent\n\ndef test_coinrun():\n random_agent.random_agent(num_envs=16, max_steps=100)\n\n\nif __name__ == '__main__':\n test_coinrun()"}}},{"rowIdx":13,"cells":{"python_code":{"kind":"string","value":"import numpy as np\nimport tensorflow as tf\nfrom baselines.a2c.utils import conv, fc, conv_to_fc, batch_to_seq, seq_to_batch, lstm\nfrom baselines.common.distributions import make_pdtype\nfrom baselines.common.input import observation_input\n\nfrom coinrun.config import Config\n\ndef impala_cnn(images, depths=[16, 32, 32]):\n \"\"\"\n Model used in the paper \"IMPALA: Scalable Distributed Deep-RL with \n Importance Weighted Actor-Learner Architectures\" https://arxiv.org/abs/1802.01561\n \"\"\"\n use_batch_norm = Config.USE_BATCH_NORM == 1\n\n dropout_layer_num = [0]\n dropout_assign_ops = []\n\n def dropout_layer(out):\n if Config.DROPOUT > 0:\n out_shape = out.get_shape().as_list()\n num_features = np.prod(out_shape[1:])\n\n var_name = 'mask_' + str(dropout_layer_num[0])\n batch_seed_shape = out_shape[1:]\n batch_seed = tf.get_variable(var_name, shape=batch_seed_shape, initializer=tf.random_uniform_initializer(minval=0, maxval=1), trainable=False)\n batch_seed_assign = tf.assign(batch_seed, tf.random_uniform(batch_seed_shape, minval=0, maxval=1))\n dropout_assign_ops.append(batch_seed_assign)\n\n curr_mask = tf.sign(tf.nn.relu(batch_seed[None,...] - Config.DROPOUT))\n\n curr_mask = curr_mask * (1.0 / (1.0 - Config.DROPOUT))\n\n out = out * curr_mask\n\n dropout_layer_num[0] += 1\n\n return out\n\n def conv_layer(out, depth):\n out = tf.layers.conv2d(out, depth, 3, padding='same')\n out = dropout_layer(out)\n\n if use_batch_norm:\n out = tf.contrib.layers.batch_norm(out, center=True, scale=True, is_training=True)\n\n return out\n\n def residual_block(inputs):\n depth = inputs.get_shape()[-1].value\n \n out = tf.nn.relu(inputs)\n\n out = conv_layer(out, depth)\n out = tf.nn.relu(out)\n out = conv_layer(out, depth)\n return out + inputs\n\n def conv_sequence(inputs, depth):\n out = conv_layer(inputs, depth)\n out = tf.layers.max_pooling2d(out, pool_size=3, strides=2, padding='same')\n out = residual_block(out)\n out = residual_block(out)\n return out\n\n out = images\n for depth in depths:\n out = conv_sequence(out, depth)\n\n out = tf.layers.flatten(out)\n out = tf.nn.relu(out)\n out = tf.layers.dense(out, 256, activation=tf.nn.relu)\n\n return out, dropout_assign_ops\n\ndef nature_cnn(scaled_images, **conv_kwargs):\n \"\"\"\n Model used in the paper \"Human-level control through deep reinforcement learning\" \n https://www.nature.com/articles/nature14236\n \"\"\"\n\n def activ(curr):\n return tf.nn.relu(curr)\n\n h = activ(conv(scaled_images, 'c1', nf=32, rf=8, stride=4, init_scale=np.sqrt(2),\n **conv_kwargs))\n h2 = activ(conv(h, 'c2', nf=64, rf=4, stride=2, init_scale=np.sqrt(2), **conv_kwargs))\n h3 = activ(conv(h2, 'c3', nf=64, rf=3, stride=1, init_scale=np.sqrt(2), **conv_kwargs))\n h3 = conv_to_fc(h3)\n return activ(fc(h3, 'fc1', nh=512, init_scale=np.sqrt(2)))\n\ndef choose_cnn(images):\n arch = Config.ARCHITECTURE\n scaled_images = tf.cast(images, tf.float32) / 255.\n dropout_assign_ops = []\n\n if arch == 'nature':\n out = nature_cnn(scaled_images)\n elif arch == 'impala':\n out, dropout_assign_ops = impala_cnn(scaled_images)\n elif arch == 'impalalarge':\n out, dropout_assign_ops = impala_cnn(scaled_images, depths=[32, 64, 64, 64, 64])\n else:\n assert(False)\n\n return out, dropout_assign_ops\n\nclass LstmPolicy(object):\n\n def __init__(self, sess, ob_space, ac_space, nbatch, nsteps, nlstm=256):\n nenv = nbatch // nsteps\n self.pdtype = make_pdtype(ac_space)\n X, processed_x = observation_input(ob_space, nbatch)\n\n M = tf.placeholder(tf.float32, [nbatch]) #mask (done t-1)\n S = tf.placeholder(tf.float32, [nenv, nlstm*2]) #states\n with tf.variable_scope(\"model\", reuse=tf.AUTO_REUSE):\n h, self.dropout_assign_ops = choose_cnn(processed_x)\n xs = batch_to_seq(h, nenv, nsteps)\n ms = batch_to_seq(M, nenv, nsteps)\n h5, snew = lstm(xs, ms, S, 'lstm1', nh=nlstm)\n h5 = seq_to_batch(h5)\n vf = fc(h5, 'v', 1)[:,0]\n self.pd, self.pi = self.pdtype.pdfromlatent(h5)\n\n a0 = self.pd.sample()\n neglogp0 = self.pd.neglogp(a0)\n self.initial_state = np.zeros((nenv, nlstm*2), dtype=np.float32)\n\n def step(ob, state, mask):\n return sess.run([a0, vf, snew, neglogp0], {X:ob, S:state, M:mask})\n\n def value(ob, state, mask):\n return sess.run(vf, {X:ob, S:state, M:mask})\n\n self.X = X\n self.M = M\n self.S = S\n self.vf = vf\n self.step = step\n self.value = value\n\nclass CnnPolicy(object):\n def __init__(self, sess, ob_space, ac_space, nbatch, nsteps, **conv_kwargs): #pylint: disable=W0613\n self.pdtype = make_pdtype(ac_space)\n X, processed_x = observation_input(ob_space, nbatch)\n\n with tf.variable_scope(\"model\", reuse=tf.AUTO_REUSE):\n h, self.dropout_assign_ops = choose_cnn(processed_x)\n vf = fc(h, 'v', 1)[:,0]\n self.pd, self.pi = self.pdtype.pdfromlatent(h, init_scale=0.01)\n\n a0 = self.pd.sample()\n neglogp0 = self.pd.neglogp(a0)\n self.initial_state = None\n\n def step(ob, *_args, **_kwargs):\n a, v, neglogp = sess.run([a0, vf, neglogp0], {X:ob})\n return a, v, self.initial_state, neglogp\n\n def value(ob, *_args, **_kwargs):\n return sess.run(vf, {X:ob})\n\n self.X = X\n self.vf = vf\n self.step = step\n self.value = value\n\n\ndef get_policy():\n use_lstm = Config.USE_LSTM\n \n if use_lstm == 1:\n policy = LstmPolicy\n elif use_lstm == 0:\n policy = CnnPolicy\n else:\n assert(False)\n\n return policy\n"}}},{"rowIdx":14,"cells":{"python_code":{"kind":"string","value":"\"\"\"\nPython interface to the CoinRun shared library using ctypes.\n\nOn import, this will attempt to build the shared library.\n\"\"\"\n\nimport os\nimport atexit\nimport random\nimport sys\nfrom ctypes import c_int, c_char_p, c_float, c_bool\n\nimport gym\nimport gym.spaces\nimport numpy as np\nimport numpy.ctypeslib as npct\nfrom baselines.common.vec_env import VecEnv\nfrom baselines import logger\n\nfrom coinrun.config import Config\n\nfrom mpi4py import MPI\nfrom baselines.common import mpi_util\n\n# if the environment is crashing, try using the debug build to get\n# a readable stack trace\nDEBUG = False\nSCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))\n\ngame_versions = {\n 'standard': 1000,\n 'platform': 1001,\n 'maze': 1002,\n}\n\ndef build():\n lrank, _lsize = mpi_util.get_local_rank_size(MPI.COMM_WORLD)\n if lrank == 0:\n dirname = os.path.dirname(__file__)\n if len(dirname):\n make_cmd = \"QT_SELECT=5 make -C %s\" % dirname\n else:\n make_cmd = \"QT_SELECT=5 make\"\n\n r = os.system(make_cmd)\n if r != 0:\n logger.error('coinrun: make failed')\n sys.exit(1)\n MPI.COMM_WORLD.barrier()\n\nbuild()\n\nif DEBUG:\n lib_path = '.build-debug/coinrun_cpp_d'\nelse:\n lib_path = '.build-release/coinrun_cpp'\n\nlib = npct.load_library(lib_path, os.path.dirname(__file__))\nlib.init.argtypes = [c_int]\nlib.get_NUM_ACTIONS.restype = c_int\nlib.get_RES_W.restype = c_int\nlib.get_RES_H.restype = c_int\nlib.get_VIDEORES.restype = c_int\n\nlib.vec_create.argtypes = [\n c_int, # game_type\n c_int, # nenvs\n c_int, # lump_n\n c_bool, # want_hires_render\n c_float, # default_zoom\n ]\nlib.vec_create.restype = c_int\n\nlib.vec_close.argtypes = [c_int]\n\nlib.vec_step_async_discrete.argtypes = [c_int, npct.ndpointer(dtype=np.int32, ndim=1)]\n\nlib.initialize_args.argtypes = [npct.ndpointer(dtype=np.int32, ndim=1)]\nlib.initialize_set_monitor_dir.argtypes = [c_char_p, c_int]\n\nlib.vec_wait.argtypes = [\n c_int,\n npct.ndpointer(dtype=np.uint8, ndim=4), # normal rgb\n npct.ndpointer(dtype=np.uint8, ndim=4), # larger rgb for render()\n npct.ndpointer(dtype=np.float32, ndim=1), # rew\n npct.ndpointer(dtype=np.bool, ndim=1), # done\n ]\n\nalready_inited = False\n\ndef init_args_and_threads(cpu_count=4,\n monitor_csv_policy='all',\n rand_seed=None):\n \"\"\"\n Perform one-time global init for the CoinRun library. This must be called\n before creating an instance of CoinRunVecEnv. You should not\n call this multiple times from the same process.\n \"\"\"\n os.environ['COINRUN_RESOURCES_PATH'] = os.path.join(SCRIPT_DIR, 'assets')\n is_high_difficulty = Config.HIGH_DIFFICULTY\n\n if rand_seed is None:\n rand_seed = random.SystemRandom().randint(0, 1000000000)\n\n # ensure different MPI processes get different seeds (just in case SystemRandom implementation is poor)\n mpi_rank, mpi_size = mpi_util.get_local_rank_size(MPI.COMM_WORLD)\n rand_seed = rand_seed - rand_seed % mpi_size + mpi_rank\n\n int_args = np.array([int(is_high_difficulty), Config.NUM_LEVELS, int(Config.PAINT_VEL_INFO), Config.USE_DATA_AUGMENTATION, game_versions[Config.GAME_TYPE], Config.SET_SEED, rand_seed]).astype(np.int32)\n\n lib.initialize_args(int_args)\n lib.initialize_set_monitor_dir(logger.get_dir().encode('utf-8'), {'off': 0, 'first_env': 1, 'all': 2}[monitor_csv_policy])\n\n global already_inited\n if already_inited:\n return\n\n lib.init(cpu_count)\n already_inited = True\n\n@atexit.register\ndef shutdown():\n global already_inited\n if not already_inited:\n return\n lib.coinrun_shutdown()\n\nclass CoinRunVecEnv(VecEnv):\n \"\"\"\n This is the CoinRun VecEnv, all CoinRun environments are just instances\n of this class with different values for `game_type`\n\n `game_type`: int game type corresponding to the game type to create, see `enum GameType` in `coinrun.cpp`\n `num_envs`: number of environments to create in this VecEnv\n `lump_n`: only used when the environment creates `monitor.csv` files\n `default_zoom`: controls how much of the level the agent can see\n \"\"\"\n def __init__(self, game_type, num_envs, lump_n=0, default_zoom=5.0):\n self.metadata = {'render.modes': []}\n self.reward_range = (-float('inf'), float('inf'))\n\n self.NUM_ACTIONS = lib.get_NUM_ACTIONS()\n self.RES_W = lib.get_RES_W()\n self.RES_H = lib.get_RES_H()\n self.VIDEORES = lib.get_VIDEORES()\n\n self.buf_rew = np.zeros([num_envs], dtype=np.float32)\n self.buf_done = np.zeros([num_envs], dtype=np.bool)\n self.buf_rgb = np.zeros([num_envs, self.RES_H, self.RES_W, 3], dtype=np.uint8)\n self.hires_render = Config.IS_HIGH_RES\n if self.hires_render:\n self.buf_render_rgb = np.zeros([num_envs, self.VIDEORES, self.VIDEORES, 3], dtype=np.uint8)\n else:\n self.buf_render_rgb = np.zeros([1, 1, 1, 1], dtype=np.uint8)\n\n num_channels = 1 if Config.USE_BLACK_WHITE else 3\n obs_space = gym.spaces.Box(0, 255, shape=[self.RES_H, self.RES_W, num_channels], dtype=np.uint8)\n\n super().__init__(\n num_envs=num_envs,\n observation_space=obs_space,\n action_space=gym.spaces.Discrete(self.NUM_ACTIONS),\n )\n self.handle = lib.vec_create(\n game_versions[game_type],\n self.num_envs,\n lump_n,\n self.hires_render,\n default_zoom)\n self.dummy_info = [{} for _ in range(num_envs)]\n\n def __del__(self):\n if hasattr(self, 'handle'):\n lib.vec_close(self.handle)\n self.handle = 0\n\n def close(self):\n lib.vec_close(self.handle)\n self.handle = 0\n\n def reset(self):\n print(\"CoinRun ignores resets\")\n obs, _, _, _ = self.step_wait()\n return obs\n\n def get_images(self):\n if self.hires_render:\n return self.buf_render_rgb\n else:\n return self.buf_rgb\n\n def step_async(self, actions):\n assert actions.dtype in [np.int32, np.int64]\n actions = actions.astype(np.int32)\n lib.vec_step_async_discrete(self.handle, actions)\n\n def step_wait(self):\n self.buf_rew = np.zeros_like(self.buf_rew)\n self.buf_done = np.zeros_like(self.buf_done)\n\n lib.vec_wait(\n self.handle,\n self.buf_rgb,\n self.buf_render_rgb,\n self.buf_rew,\n self.buf_done)\n\n obs_frames = self.buf_rgb\n\n if Config.USE_BLACK_WHITE:\n obs_frames = np.mean(obs_frames, axis=-1).astype(np.uint8)[...,None]\n\n return obs_frames, self.buf_rew, self.buf_done, self.dummy_info\n\ndef make(env_id, num_envs, **kwargs):\n assert env_id in game_versions, 'cannot find environment \"%s\", maybe you mean one of %s' % (env_id, list(game_versions.keys()))\n return CoinRunVecEnv(env_id, num_envs, **kwargs)\n"}}},{"rowIdx":15,"cells":{"python_code":{"kind":"string","value":"import json\nimport pickle\nimport math\nimport sys\nimport argparse\nimport warnings\n\nfrom os import makedirs\nfrom os.path import basename, join, exists, dirname, splitext, realpath\n\nfrom wikidata_linker_utils.progressbar import get_progress_bar\nfrom dataset import TSVDataset, CombinedDataset, H5Dataset, ClassificationHandler\nfrom batchifier import (iter_batches_single_threaded,\n requires_vocab,\n requires_character_convolution,\n get_feature_vocabs)\nimport tensorflow as tf\nimport numpy as np\n\ntry:\n RNNCell = tf.nn.rnn_cell.RNNCell\n TFLSTMCell = tf.nn.rnn_cell.LSTMCell\n MultiRNNCell = tf.nn.rnn_cell.MultiRNNCell\n LSTMStateTuple = tf.nn.rnn_cell.LSTMStateTuple\n from tensorflow.contrib.cudnn_rnn import CudnnLSTM\nexcept AttributeError:\n RNNCell = tf.contrib.rnn.RNNCell\n TFLSTMCell = tf.contrib.rnn.LSTMCell\n MultiRNNCell = tf.contrib.rnn.MultiRNNCell\n LSTMStateTuple = tf.contrib.rnn.LSTMStateTuple\n from tensorflow.contrib.cudnn_rnn.python.ops.cudnn_rnn_ops import CudnnLSTM\n\nfrom tensorflow.python.client import device_lib\n\n\nclass LazyAdamOptimizer(tf.train.AdamOptimizer):\n \"\"\"Variant of the Adam optimizer that handles sparse updates more efficiently.\n\n The original Adam algorithm maintains two moving-average accumulators for\n each trainable variable; the accumulators are updated at every step.\n This class provides lazier handling of gradient updates for sparse variables.\n It only updates moving-average accumulators for sparse variable indices that\n appear in the current batch, rather than updating the accumulators for all\n indices. Compared with the original Adam optimizer, it can provide large\n improvements in model training throughput for some applications. However, it\n provides slightly different semantics than the original Adam algorithm, and\n may lead to different empirical results.\n \"\"\"\n\n def _apply_sparse(self, grad, var):\n beta1_power = tf.cast(self._beta1_power, var.dtype.base_dtype)\n beta2_power = tf.cast(self._beta2_power, var.dtype.base_dtype)\n lr_t = tf.cast(self._lr_t, var.dtype.base_dtype)\n beta1_t = tf.cast(self._beta1_t, var.dtype.base_dtype)\n beta2_t = tf.cast(self._beta2_t, var.dtype.base_dtype)\n epsilon_t = tf.cast(self._epsilon_t, var.dtype.base_dtype)\n lr = (lr_t * tf.sqrt(1 - beta2_power) / (1 - beta1_power))\n\n # m := beta1 * m + (1 - beta1) * g_t\n # We use a slightly different version of the moving-average update formula\n # that does a better job of handling concurrent lockless updates:\n # m -= (1 - beta1) * (m - g_t)\n m = self.get_slot(var, \"m\")\n m_t_delta = tf.gather(m, grad.indices) - grad.values\n m_t = tf.scatter_sub(m, grad.indices,\n (1 - beta1_t) * m_t_delta,\n use_locking=self._use_locking)\n\n # v := beta2 * v + (1 - beta2) * (g_t * g_t)\n # We reformulate the update as:\n # v -= (1 - beta2) * (v - g_t * g_t)\n v = self.get_slot(var, \"v\")\n v_t_delta = tf.gather(v, grad.indices) - tf.square(grad.values)\n v_t = tf.scatter_sub(v, grad.indices,\n (1 - beta2_t) * v_t_delta,\n use_locking=self._use_locking)\n\n # variable -= learning_rate * m_t / (epsilon_t + sqrt(v_t))\n m_t_slice = tf.gather(m_t, grad.indices)\n v_t_slice = tf.gather(v_t, grad.indices)\n denominator_slice = tf.sqrt(v_t_slice) + epsilon_t\n var_update = tf.scatter_sub(var, grad.indices,\n lr * m_t_slice / denominator_slice,\n use_locking=self._use_locking)\n return tf.group(var_update, m_t, v_t)\n\n\ndef get_available_gpus():\n local_device_protos = device_lib.list_local_devices()\n return [x.name for x in local_device_protos if x.device_type == 'GPU']\n\ndef split(values, axis, num_splits, name=None):\n return tf.split(values, num_splits, axis=axis, name=name)\n\ndef reverse(values, axis):\n return tf.reverse(values, [axis])\n\n\ndef sparse_softmax_cross_entropy_with_logits(logits, labels):\n return tf.nn.sparse_softmax_cross_entropy_with_logits(\n logits=logits, labels=labels)\n\n\ndef concat(values, axis, name=None):\n if len(values) == 1:\n return values[0]\n return tf.concat(values, axis, name=name)\n\n\ndef concat_tensor_array(values, name=None):\n return values.stack(name=name)\n\n\ndef batch_gather_3d(values, indices):\n return tf.gather(tf.reshape(values, [-1, tf.shape(values)[2]]),\n tf.range(0, tf.shape(values)[0]) * tf.shape(values)[1] +\n indices)\n\n\ndef batch_gather_2d(values, indices):\n return tf.gather(tf.reshape(values, [-1]),\n tf.range(0, tf.shape(values)[0]) * tf.shape(values)[1] +\n indices)\n\n\ndef viterbi_decode(score, transition_params, sequence_lengths, back_prop=False,\n parallel_iterations=1):\n \"\"\"Decode the highest scoring sequence of tags inside of TensorFlow!!!\n This can be used anytime.\n Args:\n score: A [batch, seq_len, num_tags] matrix of unary potentials.\n transition_params: A [num_tags, num_tags] matrix of binary potentials.\n sequence_lengths: A [batch] int32 vector of the length of each score\n sequence.\n Returns:\n viterbi: A [batch, seq_len] list of integers containing the highest\n scoring tag indices.\n viterbi_score: A vector of float containing the score for the Viterbi\n sequence.\n \"\"\"\n sequence_lengths = tf.convert_to_tensor(\n sequence_lengths, name=\"sequence_lengths\")\n score = tf.convert_to_tensor(score, name=\"score\")\n transition_params = tf.convert_to_tensor(\n transition_params, name=\"transition_params\")\n\n if sequence_lengths.dtype != tf.int32:\n sequence_lengths = tf.cast(sequence_lengths, tf.int32)\n\n def condition(t, *args):\n \"\"\"Stop when full score sequence has been read in.\"\"\"\n return tf.less(t, tf.shape(score)[1])\n\n def body(t, trellis, backpointers, trellis_val):\n \"\"\"Perform forward viterbi pass.\"\"\"\n v = tf.expand_dims(trellis_val, 2) + tf.expand_dims(transition_params, 0)\n new_trellis_val = score[:, t, :] + tf.reduce_max(v, axis=1)\n new_trellis = trellis.write(t, new_trellis_val)\n new_backpointers = backpointers.write(\n t, tf.cast(tf.argmax(v, axis=1), tf.int32))\n return t + 1, new_trellis, new_backpointers, new_trellis_val\n\n trellis_arr = tf.TensorArray(score.dtype, size=0,\n dynamic_size=True, clear_after_read=False, infer_shape=False)\n first_trellis_val = score[:, 0, :]\n trellis_arr = trellis_arr.write(0, first_trellis_val)\n\n backpointers_arr = tf.TensorArray(tf.int32, size=0,\n dynamic_size=True, clear_after_read=False, infer_shape=False)\n backpointers_arr = backpointers_arr.write(0,\n tf.zeros_like(score[:, 0, :], dtype=tf.int32))\n\n _, trellis_out, backpointers_out, _ = tf.while_loop(\n condition, body,\n (tf.constant(1, name=\"t\", dtype=tf.int32), trellis_arr, backpointers_arr, first_trellis_val),\n parallel_iterations=parallel_iterations,\n back_prop=back_prop)\n\n trellis_out = concat_tensor_array(trellis_out)\n backpointers_out = concat_tensor_array(backpointers_out)\n # make batch-major:\n trellis_out = tf.transpose(trellis_out, [1, 0, 2])\n backpointers_out = tf.transpose(backpointers_out, [1, 0, 2])\n\n def condition(t, *args):\n return tf.less(t, tf.shape(score)[1])\n\n def body(t, viterbi, last_decision):\n backpointers_timestep = batch_gather_3d(\n backpointers_out, tf.maximum(sequence_lengths - t, 0))\n new_last_decision = batch_gather_2d(\n backpointers_timestep, last_decision)\n new_viterbi = viterbi.write(t, new_last_decision)\n return t + 1, new_viterbi, new_last_decision\n\n last_timestep = batch_gather_3d(trellis_out, sequence_lengths - 1)\n # get scores for last timestep of each batch element inside\n # trellis:\n scores = tf.reduce_max(last_timestep, axis=1)\n # get choice index for last timestep:\n last_decision = tf.cast(tf.argmax(last_timestep, axis=1), tf.int32)\n\n # decode backwards using backpointers:\n viterbi = tf.TensorArray(tf.int32, size=0,\n dynamic_size=True, clear_after_read=False, infer_shape=False)\n viterbi = viterbi.write(0, last_decision)\n _, viterbi_out, _ = tf.while_loop(\n condition, body,\n (tf.constant(1, name=\"t\", dtype=tf.int32), viterbi, last_decision),\n parallel_iterations=parallel_iterations,\n back_prop=back_prop)\n viterbi_out = concat_tensor_array(viterbi_out)\n # make batch-major:\n viterbi_out = tf.transpose(viterbi_out, [1, 0])\n viterbi_out_fwd = tf.reverse_sequence(\n viterbi_out, sequence_lengths, seq_dim=1)\n return viterbi_out_fwd, scores\n\n\ndef sum_list(elements):\n total = elements[0]\n for el in elements[1:]:\n total += el\n return total\n\n\ndef explicitly_set_fields():\n received = set()\n for argument in sys.argv:\n if argument.startswith(\"--\"):\n received.add(argument[2:])\n if argument[2:].startswith(\"no\"):\n received.add(argument[4:])\n return received\n\n\ndef save_session(session, saver, path, verbose=False):\n \"\"\"\n Call save on tf.train.Saver on a specific path to store all the variables\n of the current tensorflow session to a file for later restoring.\n\n Arguments:\n session : tf.Session\n path : str, place to save session\n \"\"\"\n makedirs(path, exist_ok=True)\n if not path.endswith(\"/\"):\n path = path + \"/\"\n\n path = join(path, \"model.ckpt\")\n if verbose:\n print(\"Saving session under %r\" % (path,), flush=True)\n saver.save(session, path)\n print(\"Saved\", flush=True)\n\n### constants for saving & loading\n\n# model config:\nOBJECTIVE_NAMES = \"OBJECTIVE_NAMES\"\nOBJECTIVE_TYPES = \"OBJECTIVE_TYPES\"\n\n# inputs:\nINPUT_PLACEHOLDERS = \"INPUT_PLACEHOLDERS\"\nLABEL_PLACEHOLDERS = \"LABEL_PLACEHOLDERS\"\nLABEL_MASK_PLACEHOLDERS = \"LABEL_MASK_PLACEHOLDERS\"\nTRAIN_OP = \"TRAIN_OP\"\nSEQUENCE_LENGTHS = \"SEQUENCE_LENGTHS\"\nIS_TRAINING = \"IS_TRAINING\"\n\n# outputs:\nDECODED = \"DECODED\"\nDECODED_SCORES = \"DECODED_SCORES\"\nUNARY_SCORES = \"UNARY_SCORES\"\n\n# per objective metrics:\nTOKEN_CORRECT = \"TOKEN_CORRECT\"\nTOKEN_CORRECT_TOTAL = \"TOKEN_CORRECT_TOTAL\"\nSENTENCE_CORRECT = \"SENTENCE_CORRECT\"\nSENTENCE_CORRECT_TOTAL = \"SENTENCE_CORRECT_TOTAL\"\n\n# aggregate metrics over all objectives\nNLL = \"NLL\"\nNLL_TOTAL = \"NLL_TOTAL\"\nTOKEN_CORRECT_ALL = \"TOKEN_CORRECT_ALL\"\nTOKEN_CORRECT_ALL_TOTAL = \"TOKEN_CORRECT_ALL_TOTAL\"\nSENTENCE_CORRECT_ALL = \"SENTENCE_CORRECT_ALL\"\nSENTENCE_CORRECT_ALL_TOTAL = \"SENTENCE_CORRECT_ALL_TOTAL\"\nCONFUSION_MATRIX = \"CONFUSION_MATRIX\"\nGLOBAL_STEP = \"global_step\"\nSUMMARIES_ASSIGNS = \"SUMMARIES_ASSIGNS\"\nSUMMARIES_PLACEHOLDERS = \"SUMMARIES_PLACEHOLDERS\"\nSUMMARIES_NAMES = \"SUMMARIES_NAMES\"\nTRAIN_SUMMARIES = \"TRAIN_SUMMARIES\"\n\nTRUE_POSITIVES = \"TRUE_POSITIVES\"\nFALSE_POSITIVES = \"FALSE_POSITIVES\"\nFALSE_NEGATIVES = \"FALSE_NEGATIVES\"\n\ndef maybe_dropout(inputs, keep_prob, is_training):\n return tf.cond(is_training,\n lambda : tf.nn.dropout(inputs, keep_prob),\n lambda : inputs\n ) if keep_prob < 1 else inputs\n\n\ndef compute_sentence_correct(correct, sequence_mask):\n any_label = tf.reduce_max(tf.cast(sequence_mask, tf.int32), 1)\n sentence_correct_total = tf.reduce_sum(any_label)\n # is 1 when all is correct, 0 otherwise\n sentence_correct = tf.reduce_sum(tf.reduce_prod(\n tf.cast(\n tf.logical_or(correct, tf.logical_not(sequence_mask)),\n tf.int32\n ),\n 1\n ) * any_label)\n return sentence_correct, sentence_correct_total\n\n\ndef lstm_activation(inputs, input_h, input_c, W, b, activation):\n # i = input_gate, j = new_input, f = forget_gate, o = output_gate\n cell_inputs = concat([inputs, input_h], axis=1)\n\n lstm_matrix = tf.nn.xw_plus_b(cell_inputs, W, b)\n preactiv = split(lstm_matrix, axis=1, num_splits=4)\n # from CUDNN docs:\n # Values 0 and 4 reference the input gate.\n # Values 1 and 5 reference the forget gate.\n # Values 2 and 6 reference the new memory gate.\n # Values 3 and 7 reference the output gate\n i, f, j, o = (\n preactiv[CUDNN_MAPPING[\"i\"]],\n preactiv[CUDNN_MAPPING[\"f\"]],\n preactiv[CUDNN_MAPPING[\"j\"]],\n preactiv[CUDNN_MAPPING[\"o\"]]\n )\n\n c = (tf.nn.sigmoid(f) * input_c +\n tf.nn.sigmoid(i) * activation(j))\n\n m = tf.nn.sigmoid(o) * activation(c)\n return (c, m)\n\n\nclass Logger(object):\n def __init__(self, session, writer):\n self.session = session\n self.writer = writer\n self._placeholders = {}\n summaries = tf.get_collection(SUMMARIES_ASSIGNS)\n summaries_pholders = tf.get_collection(SUMMARIES_PLACEHOLDERS)\n summaries_names = [name.decode(\"utf-8\")\n for name in tf.get_collection(SUMMARIES_NAMES)]\n\n for summary, pholder, name in zip(summaries, summaries_pholders, summaries_names):\n self._placeholders[name] = (pholder, summary)\n\n\n def log(self, name, value, step):\n if name not in self._placeholders:\n pholder = tf.placeholder(tf.float32, [], name=name)\n summary = tf.summary.scalar(name, pholder)\n tf.add_to_collection(SUMMARIES_ASSIGNS, summary)\n tf.add_to_collection(SUMMARIES_NAMES, name)\n tf.add_to_collection(SUMMARIES_PLACEHOLDERS, pholder)\n self._placeholders[name] = (pholder, summary)\n pholder, summary = self._placeholders[name]\n res = self.session.run(summary, {pholder:value})\n self.writer.add_summary(res, step)\n\n\nclass ParametrizedLSTMCell(RNNCell):\n def __init__(self, weights, biases, hidden_size):\n self._weights = weights\n self._biases = biases\n self.hidden_size = hidden_size\n\n @property\n def state_size(self):\n return (self.hidden_size, self.hidden_size)\n\n @property\n def output_size(self):\n return self.hidden_size\n\n def __call__(self, inputs, state, scope=None):\n input_h, input_c = state\n c, m = lstm_activation(inputs,\n input_h=input_h,\n input_c=input_c,\n b=self._biases,\n W=self._weights,\n activation=tf.nn.tanh)\n return m, (m, c)\n\n\nclass LSTMCell(TFLSTMCell):\n def __init__(self,\n num_units,\n keep_prob=1.0,\n is_training=False):\n self._is_training = is_training\n self._keep_prob = keep_prob\n TFLSTMCell.__init__(\n self,\n num_units=num_units,\n state_is_tuple=True\n )\n\n def __call__(self, inputs, state, scope=None):\n (c_prev, m_prev) = state\n\n dtype = inputs.dtype\n input_size = inputs.get_shape().with_rank(2)[1]\n if input_size.value is None:\n raise ValueError(\"Could not infer input size from inputs.get_shape()[-1]\")\n with tf.variable_scope(scope or type(self).__name__,\n initializer=self._initializer): # \"LSTMCell\"\n concat_w = _get_concat_variable(\n \"W\", [input_size.value + self._num_units, 4 * self._num_units],\n dtype, 1)\n\n b = tf.get_variable(\n \"B\", shape=[4 * self._num_units],\n initializer=tf.zeros_initializer(), dtype=dtype)\n\n c, m = lstm_activation(inputs,\n input_c=c_prev,\n input_h=m_prev,\n W=concat_w,\n b=b,\n activation=self._activation,\n keep_prob=self._keep_prob,\n is_training=self._is_training,\n forget_bias=self._forget_bias)\n return m, LSTMStateTuple(c, m)\n\n\n\ndef cudnn_lstm_parameter_size(input_size, hidden_size):\n \"\"\"Number of parameters in a single CuDNN LSTM cell.\"\"\"\n biases = 8 * hidden_size\n weights = 4 * (hidden_size * input_size) + 4 * (hidden_size * hidden_size)\n return biases + weights\n\n\ndef direction_to_num_directions(direction):\n if direction == \"unidirectional\":\n return 1\n elif direction == \"bidirectional\":\n return 2\n else:\n raise ValueError(\"Unknown direction: %r.\" % (direction,))\n\n\ndef estimate_cudnn_parameter_size(num_layers,\n input_size,\n hidden_size,\n input_mode,\n direction):\n \"\"\"\n Compute the number of parameters needed to\n construct a stack of LSTMs. Assumes the hidden states\n of bidirectional LSTMs are concatenated before being\n sent to the next layer up.\n \"\"\"\n num_directions = direction_to_num_directions(direction)\n params = 0\n isize = input_size\n for layer in range(num_layers):\n for direction in range(num_directions):\n params += cudnn_lstm_parameter_size(\n isize, hidden_size\n )\n isize = hidden_size * num_directions\n return params\n\n# cudnn conversion to dynamic RNN:\nCUDNN_LAYER_WEIGHT_ORDER = [\n \"x\", \"x\", \"x\", \"x\", \"h\", \"h\", \"h\", \"h\"\n]\nCUDNN_LAYER_BIAS_ORDER = [\n \"bx\", \"bx\", \"bx\", \"bx\", \"bh\", \"bh\", \"bh\", \"bh\"\n]\nCUDNN_TRANSPOSED = True\nCUDNN_MAPPING = {\"i\": 0, \"f\": 1, \"j\": 2, \"o\": 3}\n\n\ndef consume_biases_direction(params, old_offset, hidden_size, isize):\n offset = old_offset\n layer_biases_x = []\n layer_biases_h = []\n\n for piece in CUDNN_LAYER_BIAS_ORDER:\n if piece == \"bx\":\n layer_biases_x.append(\n params[offset:offset + hidden_size]\n )\n offset += hidden_size\n elif piece == \"bh\":\n layer_biases_h.append(\n params[offset:offset + hidden_size]\n )\n offset += hidden_size\n else:\n raise ValueError(\"Unknown cudnn piece %r.\" % (piece,))\n b = concat(layer_biases_x, axis=0) + concat(layer_biases_h, axis=0)\n return b, offset\n\n\ndef consume_weights_direction(params, old_offset, hidden_size, isize):\n offset = old_offset\n layer_weights_x = []\n layer_weights_h = []\n for piece in CUDNN_LAYER_WEIGHT_ORDER:\n if piece == \"x\":\n layer_weights_x.append(\n tf.reshape(\n params[offset:offset + hidden_size * isize],\n [hidden_size, isize] if CUDNN_TRANSPOSED else [isize, hidden_size]\n )\n )\n offset += hidden_size * isize\n elif piece == \"h\":\n layer_weights_h.append(\n tf.reshape(\n params[offset:offset + hidden_size * hidden_size],\n [hidden_size, hidden_size]\n )\n )\n offset += hidden_size * hidden_size\n else:\n raise ValueError(\"Unknown cudnn piece %r.\" % (piece,))\n if CUDNN_TRANSPOSED:\n W_T = concat([concat(layer_weights_x, axis=0), concat(layer_weights_h, axis=0)], axis=1)\n W = tf.transpose(W_T)\n else:\n W = concat([concat(layer_weights_x, axis=1), concat(layer_weights_h, axis=1)], axis=0)\n return W, offset\n\n\ndef decompose_layer_params(params, num_layers,\n hidden_size, cell_input_size,\n input_mode, direction, create_fn):\n \"\"\"\n This operation converts the opaque cudnn params into a set of\n usable weight matrices.\n Args:\n params : Tensor, opaque cudnn params tensor\n num_layers : int, number of stacked LSTMs.\n hidden_size : int, number of neurons in each LSTM.\n cell_input_size : int, input size for the LSTMs.\n input_mode: whether a pre-projection was used or not. Currently only\n 'linear_input' is supported (e.g. CuDNN does its own projection\n internally)\n direction : str, 'unidirectional' or 'bidirectional'.\n create_fn: callback for weight creation. Receives parameter slice (op),\n layer (int), direction (0 = fwd, 1 = bwd),\n parameter_index (0 = W, 1 = b).\n Returns:\n weights : list of lists of Tensors in the format:\n first list is indexed layers,\n inner list is indexed by direction (fwd, bwd),\n tensors in the inner list are (Weights, biases)\n \"\"\"\n if input_mode != \"linear_input\":\n raise ValueError(\"Only input_mode == linear_input supported for now.\")\n num_directions = direction_to_num_directions(direction)\n offset = 0\n all_weights = [[[] for j in range(num_directions)]\n for i in range(num_layers)]\n isize = cell_input_size\n with tf.variable_scope(\"DecomposeCudnnParams\"):\n for layer in range(num_layers):\n with tf.variable_scope(\"Layer{}\".format(layer)):\n for direction in range(num_directions):\n with tf.variable_scope(\"fwd\" if direction == 0 else \"bwd\"):\n with tf.variable_scope(\"weights\"):\n W, offset = consume_weights_direction(\n params,\n old_offset=offset,\n hidden_size=hidden_size,\n isize=isize)\n all_weights[layer][direction].append(\n create_fn(W, layer, direction, 0))\n isize = hidden_size * num_directions\n isize = cell_input_size\n for layer in range(num_layers):\n with tf.variable_scope(\"Layer{}\".format(layer)):\n for direction in range(num_directions):\n with tf.variable_scope(\"fwd\" if direction == 0 else \"bwd\"):\n with tf.variable_scope(\"biases\"):\n b, offset = consume_biases_direction(\n params,\n old_offset=offset,\n hidden_size=hidden_size,\n isize=isize)\n all_weights[layer][direction].append(\n create_fn(b, layer, direction, 1))\n isize = hidden_size * num_directions\n return all_weights\n\n\ndef create_decomposed_variable(param, lidx, didx, pidx):\n with tf.device(\"cpu\"):\n return tf.get_variable(\"w\" if pidx == 0 else \"b\",\n shape=param.get_shape().as_list(),\n dtype=param.dtype,\n trainable=False,\n collections=[tf.GraphKeys.GLOBAL_VARIABLES,\n \"excluded_variables\"])\n\n\ndef cpu_cudnn_params(params, num_layers, hidden_size, cell_input_size, input_mode,\n direction):\n \"\"\"\n This operation converts the opaque cudnn params into a set of\n usable weight matrices, and caches the conversion.\n Args:\n params : Tensor, opaque cudnn params tensor\n num_layers : int, number of stacked LSTMs.\n hidden_size : int, number of neurons in each LSTM.\n cell_input_size : int, input size for the LSTMs.\n input_mode: whether a pre-projection was used or not. Currently only\n 'linear_input' is supported (e.g. CuDNN does its own projection\n internally)\n direction : str, 'unidirectional' or 'bidirectional'.\n skip_creation : bool, whether to build variables.\n Returns:\n weights : list of lists of Tensors in the format:\n first list is indexed layers,\n inner list is indexed by direction (fwd, bwd),\n tensors in the inner list are (Weights, biases)\n \"\"\"\n # create a boolean status variable that checks whether the\n # weights have been converted to cpu format:\n with tf.device(\"cpu\"):\n cpu_conversion_status = tf.get_variable(\n name=\"CudnnConversionStatus\", dtype=tf.float32,\n initializer=tf.zeros_initializer(), shape=[],\n trainable=False,\n collections=[tf.GraphKeys.GLOBAL_VARIABLES])\n # create a fresh copy of the weights (not trainable)\n reshaped = decompose_layer_params(\n params,\n num_layers=num_layers,\n hidden_size=hidden_size,\n cell_input_size=cell_input_size,\n input_mode=input_mode,\n direction=direction,\n create_fn=create_decomposed_variable)\n\n def cpu_convert():\n all_assigns = decompose_layer_params(\n params,\n num_layers=num_layers,\n hidden_size=hidden_size,\n cell_input_size=cell_input_size,\n input_mode=input_mode,\n direction=direction,\n create_fn=lambda p, lidx, didx, pidx: tf.assign(reshaped[lidx][didx][pidx], p))\n all_assigns = [assign for layer_assign in all_assigns\n for dir_assign in layer_assign\n for assign in dir_assign]\n all_assigns.append(tf.assign(cpu_conversion_status, tf.constant(1.0, dtype=tf.float32)))\n all_assigns.append(tf.Print(cpu_conversion_status, [0],\n message=\"Converted cudnn weights to CPU format. \"))\n with tf.control_dependencies(all_assigns):\n ret = tf.identity(cpu_conversion_status)\n return ret\n # cache the reshaping/concatenating\n ensure_conversion = tf.cond(tf.greater(cpu_conversion_status, 0),\n lambda: cpu_conversion_status,\n cpu_convert)\n # if weights are already reshaped, go ahead:\n with tf.control_dependencies([ensure_conversion]):\n # wrap with identity to ensure there is a dependency between assignment\n # and using the weights:\n all_params = [[[tf.identity(p) for p in dir_param]\n for dir_param in layer_param]\n for layer_param in reshaped]\n return all_params\n\n\nclass CpuCudnnLSTM(object):\n def __init__(self, num_layers, hidden_size,\n cell_input_size, input_mode, direction):\n self.num_layers = num_layers\n self.hidden_size = hidden_size\n self.cell_input_size = cell_input_size\n self.input_mode = input_mode\n self.direction = direction\n\n def __call__(self,\n inputs,\n input_h,\n input_c,\n params,\n is_training=True):\n layer_params = cpu_cudnn_params(params,\n num_layers=self.num_layers,\n hidden_size=self.hidden_size,\n cell_input_size=self.cell_input_size,\n input_mode=self.input_mode,\n direction=self.direction)\n REVERSED = 1\n layer_inputs = inputs\n cell_idx = 0\n for layer_param in layer_params:\n hidden_fwd_bwd = []\n final_output_c = []\n final_output_h = []\n for direction, (W, b) in enumerate(layer_param):\n if direction == REVERSED:\n layer_inputs = reverse(layer_inputs, axis=0)\n hiddens, (output_h, output_c) = tf.nn.dynamic_rnn(\n cell=ParametrizedLSTMCell(W, b, self.hidden_size),\n inputs=layer_inputs,\n dtype=inputs.dtype,\n time_major=True,\n initial_state=(input_h[cell_idx], input_c[cell_idx]))\n if direction == REVERSED:\n hiddens = reverse(hiddens, axis=0)\n hidden_fwd_bwd.append(hiddens)\n final_output_c.append(tf.expand_dims(output_c, 0))\n final_output_h.append(tf.expand_dims(output_h, 0))\n cell_idx += 1\n if len(hidden_fwd_bwd) > 1:\n layer_inputs = concat(hidden_fwd_bwd, axis=2)\n final_output_c = concat(final_output_c, axis=0)\n final_output_h = concat(final_output_h, axis=0)\n else:\n layer_inputs = hidden_fwd_bwd[0]\n final_output_c = final_output_c[0]\n final_output_h = final_output_h[0]\n return layer_inputs, final_output_h, final_output_c\n\n\ndef highway(x, activation_fn=tf.nn.relu, scope=None):\n size = x.get_shape()[-1].value\n with tf.variable_scope(scope or \"HighwayLayer\"):\n activ = tf.contrib.layers.fully_connected(\n x, size * 2, activation_fn=None, scope=\"FC\"\n )\n transform = tf.sigmoid(activ[..., :size], name=\"transform_gate\")\n hidden = activation_fn(activ[..., size:])\n carry = 1.0 - transform\n return tf.add(hidden * transform, x * carry, \"y\")\n\n\ndef conv2d(inputs, output_dim, k_h, k_w,\n stddev=0.02, scope=None,\n weight_noise=0.0, is_training=True):\n with tf.variable_scope(scope or \"Conv2D\"):\n w = tf.get_variable('w', [k_h, k_w, inputs.get_shape()[-1], output_dim],\n initializer=tf.truncated_normal_initializer(stddev=stddev))\n if weight_noise > 0 and not isinstance(is_training, bool):\n w = add_weight_noise(w, is_training=is_training, stddev=weight_noise)\n return tf.nn.conv2d(inputs, w, strides=[1, 1, 1, 1], padding=\"VALID\")\n\n\n\ndef character_convolution(inputs, feature):\n inputs_2d = tf.reshape(inputs,\n [tf.shape(inputs)[0] * tf.shape(inputs)[1], tf.shape(inputs)[2]]\n )\n inputs_3d = embedding_lookup(\n inputs_2d,\n dim=feature[\"dimension\"],\n # 255 different bytes (uint8)\n # & start and end symbol:\n size=257,\n dtype=tf.float32,\n mask_negative=True)\n inputs_4d = tf.expand_dims(inputs_3d, 1)\n feature_pools = []\n for idx, conv_filter in enumerate(feature[\"filters\"]):\n width, channels = conv_filter[\"width\"], conv_filter[\"channels\"]\n # [batch * time x 1 x word_length x embed_dim x feature_map_dim]\n conv = tf.squeeze(conv2d(inputs_4d, channels, 1, width, scope=\"CharacterConvolution%d\" % (idx,)), [1])\n # remove word dimension\n pool = tf.reduce_max(conv, 1)\n feature_pools.append(pool)\n activations = concat(feature_pools, axis=1)\n channels_out = sum(conv_filter[\"channels\"] for conv_filter in feature[\"filters\"])\n activations = tf.reshape(\n tf.tanh(activations),\n [tf.shape(inputs)[0], tf.shape(inputs)[1], channels_out],\n name=\"CharacterConvolutionPooled\")\n for idx in range(feature[\"highway_layers\"]):\n activations = highway(activations, scope=\"HighwayLayer%d\" % (idx,),\n activation_fn=tf.tanh)\n return activations\n\n\ndef feature_dtype(feat):\n if requires_vocab(feat):\n return tf.int32\n elif feat[\"type\"] in {\"digit\", \"punctuation_count\", \"uppercase\"}:\n return tf.float32\n elif requires_character_convolution(feat):\n return tf.int32\n else:\n raise ValueError(\"unknown feature %r.\" % (feat,))\n\n\ndef feature_shape(feature):\n if requires_vocab(feature) or feature[\"type\"] in {'digit', 'punctuation_count', 'uppercase'}:\n return [None, None]\n elif requires_character_convolution(feature):\n return [None, None, None]\n else:\n raise ValueError(\"unknown feature %r.\" % (feature,))\n\n\ndef build_inputs(features, objectives, fused, class_weights,\n class_weights_clipval):\n input_placeholders = []\n labels = []\n labels_mask = []\n labels_class_weights = []\n max_output_vocab = max(len(obj[\"vocab\"]) for obj in objectives)\n\n with tf.variable_scope(\"Inputs\"):\n is_training = tf.placeholder(tf.bool, [], name=\"is_training\")\n tf.add_to_collection(IS_TRAINING, is_training)\n for idx, feat in enumerate(features):\n input_placeholder = tf.placeholder(\n feature_dtype(feat), feature_shape(feat),\n name=\"input_placeholders_%d\" % (idx,)\n )\n input_placeholders.append(input_placeholder)\n tf.add_to_collection(INPUT_PLACEHOLDERS, input_placeholder)\n\n if fused:\n label_placeholder = tf.placeholder(\n tf.int32, [None, None, len(objectives)]\n )\n labels_mask_placeholder = tf.placeholder(\n tf.bool, [None, None, len(objectives)], name=\"labels_mask\"\n )\n\n labels.append(label_placeholder)\n labels_mask.append(labels_mask_placeholder)\n tf.add_to_collection(LABEL_PLACEHOLDERS, label_placeholder)\n tf.add_to_collection(LABEL_MASK_PLACEHOLDERS, labels_mask_placeholder)\n\n if class_weights:\n with tf.variable_scope(\"FusedClassWeights\"):\n init_class_weights = tf.get_variable(\n name=\"class_weights\",\n shape=[len(objectives) * max_output_vocab],\n initializer=tf.constant_initializer(1),\n dtype=tf.int64,\n trainable=False)\n init_class_count = tf.get_variable(\n name=\"class_weights_denominator\",\n shape=[len(objectives)],\n initializer=tf.constant_initializer(1),\n dtype=tf.int64,\n trainable=False)\n\n def update_class_weights():\n mask_as_ints = tf.cast(tf.reshape(labels_mask_placeholder, [-1, len(objectives)]), tf.int64)\n updated_cls_weights = tf.scatter_add(\n init_class_weights,\n tf.reshape(label_placeholder + tf.reshape(tf.range(len(objectives)) * max_output_vocab, [1, 1, len(objectives)]), [-1]),\n tf.reshape(mask_as_ints, [-1])\n )\n updated_class_count = tf.assign_add(init_class_count, tf.reduce_sum(mask_as_ints, 0))\n\n # class weight: weight_i = total / class_i\n weights = tf.clip_by_value(tf.expand_dims(updated_class_count, 1) /\n tf.reshape(updated_cls_weights, [len(objectives), max_output_vocab]),\n 1e-6, class_weights_clipval)\n return tf.cast(weights, tf.float32)\n\n def return_class_weights():\n # class weight: weight_i = total / class_i\n return tf.cast(\n tf.clip_by_value(tf.expand_dims(init_class_count, 1) /\n tf.reshape(init_class_weights, [len(objectives), max_output_vocab]),\n 1e-6, class_weights_clipval), tf.float32)\n\n labels_class_weights.append(\n tf.cond(is_training,\n update_class_weights,\n return_class_weights))\n else:\n labels_class_weights.append(None)\n else:\n for objective in objectives:\n with tf.variable_scope(objective[\"name\"]):\n label_placeholder = tf.placeholder(\n tf.int32, [None, None], name=\"labels\"\n )\n labels.append(label_placeholder)\n if objective[\"type\"] == \"crf\":\n labels_mask_placeholder = tf.placeholder(\n tf.bool, [None], name=\"labels_mask\"\n )\n labels_class_weights.append(None)\n elif objective[\"type\"] == \"softmax\":\n labels_mask_placeholder = tf.placeholder(\n tf.bool, [None, None], name=\"labels_mask\"\n )\n if class_weights:\n init_class_weights = tf.get_variable(\n name=\"class_weights\",\n shape=len(objective[\"vocab\"]),\n initializer=tf.constant_initializer(1),\n dtype=tf.int64,\n trainable=False)\n init_class_count = tf.get_variable(\n name=\"class_weights_denominator\",\n shape=[],\n initializer=tf.constant_initializer(1),\n dtype=tf.int64,\n trainable=False)\n\n def update_class_weights():\n mask_as_ints = tf.cast(tf.reshape(labels_mask_placeholder, [-1]), tf.int64)\n updated_cls_weights = tf.scatter_add(\n init_class_weights,\n tf.reshape(label_placeholder, [-1]),\n mask_as_ints\n )\n updated_class_count = tf.assign_add(init_class_count, tf.reduce_sum(mask_as_ints))\n\n # class weight: weight_i = total / class_i\n weights = tf.clip_by_value(updated_class_count / updated_cls_weights,\n 1e-6, class_weights_clipval)\n return tf.cast(weights, tf.float32)\n\n def return_class_weights():\n # class weight: weight_i = total / class_i\n return tf.cast(\n tf.clip_by_value(init_class_count / init_class_weights,\n 1e-6, class_weights_clipval), tf.float32)\n\n labels_class_weights.append(\n tf.cond(is_training, update_class_weights, return_class_weights)\n )\n else:\n labels_class_weights.append(None)\n else:\n raise ValueError(\n \"unknown objective type %r.\" % (\n objective[\"type\"]\n )\n )\n labels_mask.append(labels_mask_placeholder)\n tf.add_to_collection(LABEL_PLACEHOLDERS, label_placeholder)\n tf.add_to_collection(LABEL_MASK_PLACEHOLDERS, labels_mask_placeholder)\n sequence_lengths = tf.placeholder(tf.int32, [None],\n name=\"sequence_lengths\")\n tf.add_to_collection(SEQUENCE_LENGTHS, sequence_lengths)\n return (input_placeholders,\n labels,\n labels_mask,\n labels_class_weights,\n sequence_lengths,\n is_training)\n\n\ndef add_weight_noise(x, is_training, stddev):\n return tf.cond(is_training,\n lambda: x + tf.random_normal(\n shape=tf.shape(x), stddev=stddev),\n lambda: x)\n\n\ndef build_recurrent(inputs, cudnn, faux_cudnn, hidden_sizes, is_training,\n keep_prob, weight_noise):\n dtype = tf.float32\n if cudnn:\n if len(hidden_sizes) == 0:\n raise ValueError(\"hidden_sizes must be a list of length > 1.\")\n hidden_size = hidden_sizes[0]\n if any(hidden_size != hsize for hsize in hidden_sizes):\n raise ValueError(\"cudnn RNN requires all hidden units \"\n \"to be the same size (got %r)\" % (\n hidden_sizes,\n ))\n num_layers = len(hidden_sizes)\n cell_input_size = inputs.get_shape()[-1].value\n\n est_size = estimate_cudnn_parameter_size(\n num_layers=num_layers,\n hidden_size=hidden_size,\n input_size=cell_input_size,\n input_mode=\"linear_input\",\n direction=\"bidirectional\"\n )\n # autoswitch to GPUs based on availability of alternatives:\n cudnn_params = tf.get_variable(\"RNNParams\",\n shape=[est_size],\n dtype=tf.float32,\n initializer=tf.contrib.layers.variance_scaling_initializer())\n if weight_noise > 0:\n cudnn_params = add_weight_noise(cudnn_params,\n stddev=weight_noise, is_training=is_training)\n if faux_cudnn:\n cudnn_cell = CpuCudnnLSTM(num_layers,\n hidden_size,\n cell_input_size,\n input_mode=\"linear_input\",\n direction=\"bidirectional\")\n else:\n cpu_cudnn_params(cudnn_params,\n num_layers=num_layers,\n hidden_size=hidden_size,\n cell_input_size=cell_input_size,\n input_mode=\"linear_input\",\n direction=\"bidirectional\")\n cudnn_cell = CudnnLSTM(num_layers,\n hidden_size,\n cell_input_size,\n input_mode=\"linear_input\",\n direction=\"bidirectional\")\n init_state = tf.fill(\n (2 * num_layers, tf.shape(inputs)[1], hidden_size),\n tf.constant(np.float32(0.0)))\n hiddens, output_h, output_c = cudnn_cell(\n inputs,\n input_h=init_state,\n input_c=init_state,\n params=cudnn_params,\n is_training=True)\n hiddens = maybe_dropout(\n hiddens,\n keep_prob,\n is_training)\n else:\n cell = MultiRNNCell(\n [LSTMCell(hsize, is_training=is_training, keep_prob=keep_prob)\n for hsize in hidden_sizes]\n )\n hiddens, _ = bidirectional_dynamic_rnn(\n cell,\n inputs,\n time_major=True,\n dtype=dtype,\n swap_memory=True\n )\n return hiddens\n\n\ndef build_embed(inputs, features, index2words, keep_prob, is_training):\n embeddings = []\n for idx, (values, feature, index2word) in enumerate(zip(inputs, features, index2words)):\n if requires_vocab(feature):\n with tf.variable_scope(\"embedding_%d\" % (idx,)):\n embedding = embedding_lookup(\n values,\n dim=feature[\"dimension\"],\n size=len(index2word),\n dtype=tf.float32,\n mask_negative=True\n )\n embeddings.append(embedding)\n elif requires_character_convolution(feature):\n embeddings.append(\n character_convolution(values, feature)\n )\n else:\n embeddings.append(tf.expand_dims(values, 2))\n return maybe_dropout(concat(embeddings, axis=2), keep_prob, is_training)\n\n\ndef crf_metrics(unary_scores, labels, transition_params, sequence_lengths,\n mask):\n \"\"\"\n Computes CRF output metrics.\n Receives:\n unary_scores : batch-major order\n labels : batch-major order\n transition_params : nclasses x nclasses matrix.\n sequence_lengths : length of each time-sequence\n mask : batch-major example mask\n\n Returns:\n token_correct,\n token_correct_total,\n sentence_correct,\n sentence_correct_total\n \"\"\"\n classes = unary_scores.get_shape()[-1].value\n decoded, scores = viterbi_decode(unary_scores,\n transition_params,\n sequence_lengths)\n\n tf.add_to_collection(UNARY_SCORES, unary_scores)\n tf.add_to_collection(DECODED, decoded)\n tf.add_to_collection(DECODED_SCORES, scores)\n\n equals_label = tf.equal(labels, decoded)\n token_correct = tf.reduce_sum(\n tf.cast(\n tf.logical_and(equals_label, mask),\n tf.int32\n )\n )\n token_correct_total = tf.reduce_sum(tf.cast(mask, tf.int32))\n tf.add_to_collection(TOKEN_CORRECT, token_correct)\n tf.add_to_collection(TOKEN_CORRECT_TOTAL, token_correct_total)\n sentence_correct, _ = compute_sentence_correct(equals_label, mask)\n sentence_correct_total = tf.reduce_sum(tf.cast(mask[:, 0], tf.int32))\n\n tf.add_to_collection(SENTENCE_CORRECT, sentence_correct)\n tf.add_to_collection(SENTENCE_CORRECT_TOTAL, sentence_correct_total)\n\n build_true_false_positives(decoded, mask, labels,\n classes, equals_label)\n\n return (token_correct, token_correct_total,\n sentence_correct, sentence_correct_total)\n\n\ndef build_true_false_positives(decoded, mask_batch_major, labels_batch_major,\n classes, equals_label):\n masked_equals_label = tf.logical_and(equals_label, mask_batch_major)\n\n # now for each class compute tp, fp, fn\n # [nclasses x batch x time]\n masked_per_class = tf.logical_and(\n tf.equal(labels_batch_major[None, :, :], tf.range(classes)[:, None, None]),\n mask_batch_major)\n\n # correct, and on label\n correct = tf.reduce_sum(tf.cast(tf.logical_and(masked_per_class, equals_label[None, :, :]), tf.int32),\n axis=[1, 2])\n # predicted a particular class\n guessed = tf.reduce_sum(tf.cast(tf.logical_and(tf.equal(decoded[None, :, :], tf.range(classes)[:, None, None]), mask_batch_major), tf.int32),\n axis=[1, 2])\n total = tf.reduce_sum(tf.cast(masked_per_class, tf.int32), axis=[1, 2])\n tp, fp, fn = correct, guessed - correct, total - correct\n\n tf.add_to_collection(TRUE_POSITIVES, tp)\n tf.add_to_collection(FALSE_POSITIVES, fp)\n tf.add_to_collection(FALSE_NEGATIVES, fn)\n\n\ndef softmax_metrics(unary_scores, labels, mask):\n \"\"\"\n Compute softmax output stats for correct/accuracy per-token/per-sentence.\n Receive\n unary_scores : time-major\n labels : time-major\n mask : time-major\n Returns:\n token_correct,\n token_correct_total,\n sentence_correct,\n sentence_correct_total\n \"\"\"\n classes = unary_scores.get_shape()[-1].value\n unary_scores_batch_major = tf.transpose(unary_scores, [1, 0, 2])\n labels_batch_major = tf.transpose(labels, [1, 0])\n mask_batch_major = tf.transpose(mask, [1, 0])\n decoded = tf.cast(tf.argmax(unary_scores_batch_major, 2), labels.dtype)\n unary_probs_batch_major = tf.nn.softmax(unary_scores_batch_major)\n scores = tf.reduce_max(unary_probs_batch_major, 2)\n\n tf.add_to_collection(UNARY_SCORES, unary_probs_batch_major)\n tf.add_to_collection(DECODED, decoded)\n tf.add_to_collection(DECODED_SCORES, scores)\n\n equals_label = tf.equal(decoded, labels_batch_major)\n\n token_correct = tf.reduce_sum(\n tf.cast(\n tf.logical_and(\n equals_label,\n mask_batch_major\n ),\n tf.int32\n )\n )\n token_correct_total = tf.reduce_sum(tf.cast(mask, tf.int32))\n tf.add_to_collection(TOKEN_CORRECT, token_correct)\n tf.add_to_collection(TOKEN_CORRECT_TOTAL, token_correct_total)\n\n sentence_correct, sentence_correct_total = compute_sentence_correct(\n equals_label, mask_batch_major\n )\n tf.add_to_collection(SENTENCE_CORRECT, sentence_correct)\n tf.add_to_collection(SENTENCE_CORRECT_TOTAL, sentence_correct_total)\n\n build_true_false_positives(decoded, mask_batch_major, labels_batch_major,\n classes, equals_label)\n return (token_correct, token_correct_total,\n sentence_correct, sentence_correct_total)\n\n\ndef add_objective_names_types(objectives):\n for objective in objectives:\n with tf.variable_scope(objective[\"name\"]):\n # store objective names in graph:\n tf.add_to_collection(OBJECTIVE_NAMES,\n tf.constant(objective[\"name\"], name=\"objective_name\")\n )\n tf.add_to_collection(OBJECTIVE_TYPES,\n tf.constant(objective[\"type\"], name=\"objective_type\")\n )\n\n\ndef build_loss(inputs, objectives, labels, labels_mask,\n labels_class_weights, fused, sequence_lengths,\n class_weights_normalize):\n \"\"\"\n Compute loss function given the objectives.\n Assumes inputs are of the form [time, batch, features].\n\n Arguments:\n ----------\n inputs : tf.Tensor\n objectives : list, objective specs\n labels : list\n labels_mask : list\n labels_class_weights : list\n sequence_lengths : tf.Tensor\n\n Returns:\n loss : tf.Tensor (scalar)\n \"\"\"\n losses = []\n negative_log_likelihoods = []\n sentence_corrects = []\n sentence_corrects_total = []\n token_corrects = []\n token_corrects_total = []\n max_output_vocab = max(len(obj[\"vocab\"]) for obj in objectives)\n total_output_size = len(objectives) * max_output_vocab\n\n add_objective_names_types(objectives)\n\n if fused:\n with tf.variable_scope(\"FusedOutputs\"):\n objective_labels = labels[0]\n mask = labels_mask[0]\n objective_class_weights = labels_class_weights[0]\n # perform all classifications at once:\n unary_scores = tf.contrib.layers.fully_connected(\n inputs, total_output_size,\n activation_fn=None\n )\n\n unary_scores = tf.reshape(unary_scores,\n [tf.shape(unary_scores)[0],\n tf.shape(unary_scores)[1],\n len(objectives),\n max_output_vocab])\n negative_log_likelihood = sparse_softmax_cross_entropy_with_logits(\n logits=unary_scores,\n labels=objective_labels\n )\n labels_mask_casted = tf.cast(mask, negative_log_likelihood.dtype)\n masked_negative_log_likelihood = negative_log_likelihood * labels_mask_casted\n if objective_class_weights is not None:\n class_weights_mask = tf.gather(\n tf.reshape(objective_class_weights, [-1]),\n objective_labels +\n tf.reshape(tf.range(len(objectives)) * max_output_vocab, [1, 1, len(objectives)]))\n if class_weights_normalize:\n masked_weighed_negative_log_likelihood_sum = masked_negative_log_likelihood * class_weights_mask\n num_predictions = tf.maximum(tf.reduce_sum(labels_mask_casted * class_weights_mask), 1e-6)\n normed_loss = masked_weighed_negative_log_likelihood_sum / (num_predictions / len(objectives))\n else:\n masked_weighed_negative_log_likelihood_sum = masked_negative_log_likelihood * class_weights_mask\n num_predictions = tf.maximum(tf.reduce_sum(labels_mask_casted), 1e-6)\n normed_loss = masked_weighed_negative_log_likelihood_sum / (num_predictions / len(objectives))\n else:\n masked_weighed_negative_log_likelihood_sum = masked_negative_log_likelihood\n num_predictions = tf.maximum(tf.reduce_sum(labels_mask_casted), 1e-6)\n normed_loss = masked_weighed_negative_log_likelihood_sum / (num_predictions / len(objectives))\n\n masked_negative_log_likelihood_sum = tf.reduce_sum(masked_negative_log_likelihood)\n losses.append(normed_loss)\n negative_log_likelihoods.append(masked_negative_log_likelihood_sum)\n\n for idx, objective in enumerate(objectives):\n with tf.variable_scope(objective[\"name\"]):\n (token_correct,\n token_correct_total,\n sentence_correct,\n sentence_correct_total) = softmax_metrics(unary_scores[:, :, idx, :len(objective[\"vocab\"])],\n labels=objective_labels[:, :, idx],\n mask=mask[:, :, idx])\n token_corrects.append(token_correct)\n token_corrects_total.append(token_correct_total)\n sentence_corrects.append(sentence_correct)\n sentence_corrects_total.append(sentence_correct_total)\n\n else:\n for objective, objective_labels, mask, objective_class_weights in zip(objectives, labels, labels_mask, labels_class_weights):\n with tf.variable_scope(objective[\"name\"]):\n if objective[\"type\"] == \"crf\":\n unary_scores = tf.contrib.layers.fully_connected(\n inputs,\n len(objective[\"vocab\"]),\n activation_fn=None\n )\n unary_scores_batch_major = tf.transpose(unary_scores, [1, 0, 2])\n labels_batch_major = tf.transpose(objective_labels, [1, 0])\n\n\n padded_unary_scores_batch_major = tf.cond(tf.greater(tf.shape(unary_scores_batch_major)[1], 1),\n lambda: unary_scores_batch_major,\n lambda: tf.pad(unary_scores_batch_major, [[0, 0], [0, 1], [0, 0]]))\n padded_labels_batch_major = tf.cond(tf.greater(tf.shape(labels_batch_major)[1], 1),\n lambda: labels_batch_major,\n lambda: tf.pad(labels_batch_major, [[0, 0], [0, 1]]))\n\n log_likelihood, transition_params = tf.contrib.crf.crf_log_likelihood(\n padded_unary_scores_batch_major, padded_labels_batch_major, sequence_lengths\n )\n labels_mask_casted = tf.cast(mask, log_likelihood.dtype)\n masked_log_likelihood = (\n log_likelihood * labels_mask_casted\n )\n masked_negative_log_likelihood_sum = -tf.reduce_sum(masked_log_likelihood)\n num_predictions = tf.maximum(tf.reduce_sum(labels_mask_casted), 1e-6)\n losses.append(masked_negative_log_likelihood_sum / num_predictions)\n negative_log_likelihoods.append(masked_negative_log_likelihood_sum)\n sequence_mask = tf.logical_and(\n tf.sequence_mask(sequence_lengths),\n # pad the time dimension:\n tf.expand_dims(mask, 1)\n )\n\n (token_correct,\n token_correct_total,\n sentence_correct,\n sentence_correct_total) = crf_metrics(unary_scores_batch_major,\n labels=labels_batch_major,\n mask=sequence_mask,\n transition_params=transition_params,\n sequence_lengths=sequence_lengths)\n elif objective[\"type\"] == 'softmax':\n unary_scores = tf.contrib.layers.fully_connected(\n inputs,\n len(objective[\"vocab\"]),\n activation_fn=None\n )\n negative_log_likelihood = sparse_softmax_cross_entropy_with_logits(\n logits=unary_scores,\n labels=objective_labels\n )\n labels_mask_casted = tf.cast(mask, negative_log_likelihood.dtype)\n masked_negative_log_likelihood = (\n negative_log_likelihood * labels_mask_casted\n )\n if objective_class_weights is not None:\n class_weights_mask = tf.gather(objective_class_weights, objective_labels)\n masked_weighed_negative_log_likelihood_sum = masked_negative_log_likelihood * class_weights_mask\n masked_negative_log_likelihood_sum = tf.reduce_sum(masked_negative_log_likelihood)\n\n if class_weights_normalize:\n num_predictions = tf.maximum(tf.reduce_sum(labels_mask_casted * class_weights_mask), 1e-6)\n normed_loss = masked_weighed_negative_log_likelihood_sum / num_predictions\n else:\n num_predictions = tf.maximum(tf.reduce_sum(labels_mask_casted), 1e-6)\n normed_loss = masked_weighed_negative_log_likelihood_sum / num_predictions\n else:\n masked_weighed_negative_log_likelihood_sum = masked_negative_log_likelihood\n masked_negative_log_likelihood_sum = tf.reduce_sum(masked_negative_log_likelihood)\n num_predictions = tf.maximum(tf.reduce_sum(labels_mask_casted), 1e-6)\n normed_loss = masked_weighed_negative_log_likelihood_sum / num_predictions\n\n losses.append(normed_loss)\n negative_log_likelihoods.append(masked_negative_log_likelihood_sum)\n\n (token_correct,\n token_correct_total,\n sentence_correct,\n sentence_correct_total) = softmax_metrics(unary_scores,\n labels=objective_labels,\n mask=mask)\n else:\n raise ValueError(\n \"unknown objective type %r\" % (objective[\"type\"],)\n )\n token_corrects.append(token_correct)\n token_corrects_total.append(token_correct_total)\n sentence_corrects.append(sentence_correct)\n sentence_corrects_total.append(sentence_correct_total)\n # aggregate metrics for all objectives:\n total_loss = tf.reduce_sum(sum_list(losses))\n tf.summary.scalar(\"BatchLoss\", total_loss)\n neg_log_likelihood_total = sum_list(negative_log_likelihoods)\n tf.summary.scalar(\"BatchNLL\", neg_log_likelihood_total)\n tf.add_to_collection(NLL, neg_log_likelihood_total)\n tf.add_to_collection(NLL_TOTAL, tf.shape(inputs)[1])\n\n sentence_corrects_total = sum_list(sentence_corrects_total)\n sentence_corrects = sum_list(sentence_corrects)\n tf.add_to_collection(SENTENCE_CORRECT_ALL, sentence_corrects)\n tf.add_to_collection(SENTENCE_CORRECT_ALL_TOTAL, sentence_corrects_total)\n\n token_corrects_total = sum_list(token_corrects_total)\n token_corrects = sum_list(token_corrects)\n tf.add_to_collection(TOKEN_CORRECT_ALL, token_corrects)\n tf.add_to_collection(TOKEN_CORRECT_ALL_TOTAL, token_corrects_total)\n return total_loss\n\n\ndef build_model(name,\n trainable,\n features,\n feature_index2words,\n objectives,\n keep_prob,\n input_keep_prob,\n hidden_sizes,\n freeze_rate,\n freeze_rate_anneal,\n solver,\n cudnn,\n fused,\n faux_cudnn,\n class_weights,\n class_weights_normalize,\n class_weights_clipval,\n lr,\n weight_noise,\n anneal_rate,\n clip_norm):\n # mixed output fusing is currently unsupported\n if fused and any(obj[\"type\"] != \"softmax\" for obj in objectives):\n raise ValueError(\"cannot fuse outputs and use non-softmax output.\")\n # clear all existing collections to ensure every new collection is\n # is created fresh\n graph = tf.get_default_graph()\n for collection_name in graph.get_all_collection_keys():\n graph.clear_collection(collection_name)\n\n # build a model under the model's name to prevent collisions\n # when multiple models are restored simultaneously\n with tf.variable_scope(name):\n global_step = tf.Variable(0, trainable=False, name=\"global_step\")\n tf.add_to_collection(GLOBAL_STEP, global_step)\n # model placeholders:\n (input_placeholders,\n labels,\n labels_mask,\n labels_class_weights,\n sequence_lengths,\n is_training) = build_inputs(features,\n objectives=objectives,\n fused=fused,\n class_weights=class_weights,\n class_weights_clipval=class_weights_clipval)\n embed = build_embed(input_placeholders,\n features=features,\n index2words=feature_index2words,\n is_training=is_training,\n keep_prob=input_keep_prob)\n hiddens = embed\n if len(hidden_sizes) > 0:\n hiddens = build_recurrent(hiddens,\n cudnn=cudnn,\n faux_cudnn=faux_cudnn,\n hidden_sizes=hidden_sizes,\n keep_prob=keep_prob,\n weight_noise=weight_noise,\n is_training=is_training)\n\n loss = build_loss(hiddens,\n objectives=objectives,\n fused=fused,\n labels=labels,\n labels_mask=labels_mask,\n labels_class_weights=labels_class_weights,\n class_weights_normalize=class_weights_normalize,\n sequence_lengths=sequence_lengths)\n if trainable:\n learning_rate = tf.train.exponential_decay(lr, global_step,\n 33000, anneal_rate, staircase=True)\n\n if solver == \"adam\":\n optimizer = LazyAdamOptimizer(learning_rate)\n elif solver == \"sgd\":\n optimizer = tf.train.GradientDescentOptimizer(learning_rate)\n else:\n raise ValueError(\"Unknown solver %r.\" % (solver))\n\n grad_vars = optimizer.compute_gradients(loss)\n if clip_norm > 0:\n grad_vars = [(grad if isinstance(grad, tf.IndexedSlices) else tf.clip_by_norm(grad, clip_norm), var) for grad, var in grad_vars]\n train_op = optimizer.apply_gradients(grad_vars, global_step=global_step)\n else:\n train_op = tf.no_op()\n tf.add_to_collection(TRAIN_OP, train_op)\n tf.add_to_collection(TRAIN_SUMMARIES, tf.summary.merge_all())\n\n\ndef restore_session(session,\n path,\n replace_to=None,\n replace_from=None,\n verbose=False,\n use_metagraph=True,\n only_features=False):\n \"\"\"\n Call restore on tf.train.Saver on a specific path to store all the\n variables of the current tensorflow session to a file for later restoring.\n\n Arguments:\n session : tf.Session\n path : str, place containing the session data to restore\n verbose : bool, print status messages.\n use_metagraph : bool, restore by re-creating saved metagraph.\n\n Returns:\n bool : success or failure of the restoration\n \"\"\"\n makedirs(path, exist_ok=True)\n if not path.endswith(\"/\"):\n path = path + \"/\"\n checkpoint = tf.train.get_checkpoint_state(path)\n if verbose:\n print(\"Looking for saved session under %r\" % (path,), flush=True)\n if checkpoint is None or checkpoint.model_checkpoint_path is None:\n if verbose:\n print(\"No saved session found\", flush=True)\n return False\n fname = basename(checkpoint.model_checkpoint_path)\n if verbose:\n print(\"Restoring saved session from %r\" % (join(path, fname),), flush=True)\n\n if use_metagraph:\n param_saver = tf.train.import_meta_graph(join(path, fname + \".meta\"),\n clear_devices=True)\n missing_vars = []\n else:\n if only_features:\n to_restore = {}\n whitelist = [\"embedding\", \"/RNN/\", \"/RNNParams\", \"CharacterConvolution\", \"HighwayLayer\"]\n for var in tf.global_variables():\n if any(keyword in var.name for keyword in whitelist):\n to_restore[var.name[:-2]] = var\n param_saver = tf.train.Saver(to_restore)\n else:\n if replace_to is not None and replace_from is not None:\n to_restore = {}\n for var in tf.global_variables():\n var_name = var.name[:var.name.rfind(\":\")]\n old_name = var_name.replace(replace_to, replace_from)\n to_restore[old_name] = var\n param_saver = tf.train.Saver(to_restore)\n missing_vars = []\n else:\n reader = tf.train.NewCheckpointReader(join(path, fname))\n saved_shapes = reader.get_variable_to_shape_map()\n found_vars = [var for var in tf.global_variables()\n if var.name.split(':')[0] in saved_shapes]\n missing_vars = [var for var in tf.global_variables()\n if var.name.split(':')[0] not in saved_shapes]\n param_saver = tf.train.Saver(found_vars)\n param_saver.restore(session, join(path, fname))\n session.run([var.initializer for var in missing_vars])\n return True\n\n\ndef bidirectional_dynamic_rnn(cell, inputs, dtype, time_major=True, swap_memory=False):\n with tf.variable_scope(\"forward\"):\n out_fwd, final_fwd = tf.nn.dynamic_rnn(\n cell,\n inputs,\n time_major=time_major,\n dtype=dtype,\n swap_memory=swap_memory\n )\n\n if time_major:\n reverse_axis = 0\n else:\n reverse_axis = 1\n\n with tf.variable_scope(\"backward\"):\n out_bwd, final_bwd = tf.nn.dynamic_rnn(\n cell,\n reverse(inputs, axis=reverse_axis),\n time_major=time_major,\n dtype=dtype,\n swap_memory=swap_memory\n )\n\n out_bwd = reverse(out_bwd, axis=reverse_axis)\n return concat([out_fwd, out_bwd], axis=2), (final_fwd, final_bwd)\n\n\ndef get_embedding_lookup(size, dim, dtype, reuse=None, trainable=True):\n with tf.variable_scope(tf.get_variable_scope(), reuse=reuse):\n W = tf.get_variable(\n name=\"embedding\",\n shape=[size, dim],\n dtype=dtype,\n initializer=tf.random_uniform_initializer(\n -1.0 / math.sqrt(dim),\n 1.0 / math.sqrt(dim)\n ),\n trainable=trainable\n )\n return W\n\n\ndef embedding_lookup(inputs,\n size,\n dim,\n dtype,\n reuse=None,\n mask_negative=False,\n trainable=True,\n place_on_cpu_if_big=True):\n \"\"\"\n Construct an Embedding layer that gathers\n elements from a matrix with `size` rows,\n and `dim` features using the indices stored in `x`.\n\n Arguments:\n ----------\n inputs : tf.Tensor, of integer type\n size : int, how many symbols in the lookup table\n dim : int, how many columns per symbol.\n dtype : data type for the lookup table (e.g. tf.float32)\n reuse : bool, (default None) whether the lookup table\n was already used before (thus this is weight sharing).\n mask_negative : bool, (default False) should -1s in the\n lookup input indicate padding (e.g. no lookup),\n and thus should those values be masked out post-lookup.\n trainable : bool (default True), whether the parameters of\n this lookup table can be backpropagated into (e.g.\n for Glove word vectors that are fixed pre-trained, this\n can be set to False).\n place_on_cpu_if_big : bool, if matrix is big, store it on cpu.\n Returns:\n --------\n tf.Tensor, result of tf.nn.embedding_lookup(LookupTable, inputs)\n \"\"\"\n W = get_embedding_lookup(size, dim, dtype, reuse, trainable=trainable)\n if mask_negative:\n embedded = tf.nn.embedding_lookup(W, tf.maximum(inputs, 0))\n null_mask = tf.expand_dims(\n tf.cast(\n tf.not_equal(inputs, -1),\n dtype\n ),\n -1\n )\n return embedded * null_mask\n else:\n return tf.nn.embedding_lookup(W, inputs)\n\n\ndef _get_sharded_variable(name, shape, dtype, num_shards):\n \"\"\"Get a list of sharded variables with the given dtype.\"\"\"\n if num_shards > shape[0]:\n raise ValueError(\"Too many shards: shape=%s, num_shards=%d\" %\n (shape, num_shards))\n unit_shard_size = int(math.floor(shape[0] / num_shards))\n remaining_rows = shape[0] - unit_shard_size * num_shards\n\n shards = []\n for i in range(num_shards):\n current_size = unit_shard_size\n if i < remaining_rows:\n current_size += 1\n shards.append(\n tf.get_variable(\n name + \"_%d\" % i,\n [current_size] + shape[1:],\n dtype=dtype\n )\n )\n return shards\n\n\ndef _get_concat_variable(name, shape, dtype, num_shards):\n \"\"\"Get a sharded variable concatenated into one tensor.\"\"\"\n sharded_variable = _get_sharded_variable(name, shape, dtype, num_shards)\n if len(sharded_variable) == 1:\n return sharded_variable[0]\n\n concat_name = name + \"/concat\"\n concat_full_name = tf.get_variable_scope().name + \"/\" + concat_name + \":0\"\n for value in tf.get_collection(tf.GraphKeys.CONCATENATED_VARIABLES):\n if value.name == concat_full_name:\n return value\n\n concat_variable = tf.concat_v2(sharded_variable, 0, name=concat_name)\n tf.add_to_collection(tf.GraphKeys.CONCATENATED_VARIABLES, concat_variable)\n return concat_variable\n\n\nclass SequenceModel(object):\n def __init__(self,\n objectives,\n features,\n feature_index2words,\n hidden_sizes,\n keep_prob,\n lr,\n solver,\n seed=1234,\n input_keep_prob=0.7,\n clip_norm=-1,\n name=\"SequenceTagger\",\n cudnn=False,\n anneal_rate=0.99,\n trainable=True,\n weight_noise=0.0,\n class_weights_normalize=False,\n faux_cudnn=False,\n class_weights=False,\n class_weights_clipval=1000.0,\n freeze_rate=1.0,\n fused=False,\n freeze_rate_anneal=0.8,\n create_variables=True):\n if fused and objectives[0][\"type\"] == \"crf\":\n fused = False\n\n self.keep_prob = keep_prob\n self.input_keep_prob = input_keep_prob\n self.hidden_sizes = hidden_sizes\n self.name = name\n self.objectives = objectives\n self.features = features\n self.feature_index2words = feature_index2words\n self.seed = seed\n self.lr = lr\n self.fused = fused\n self.weight_noise = weight_noise\n self.anneal_rate = anneal_rate\n self.clip_norm = clip_norm\n self.solver = solver\n self.class_weights_normalize = class_weights_normalize\n self.class_weights = class_weights\n self.class_weights_clipval = class_weights_clipval\n self.rng = np.random.RandomState(seed)\n self.cudnn = cudnn\n self.feature_word2index = [\n {w: k for k, w in enumerate(index2word)} if index2word is not None else None\n for index2word in self.feature_index2words\n ]\n self.label2index = [\n {w: k for k, w in enumerate(objective[\"vocab\"])}\n for objective in self.objectives\n ]\n\n if create_variables:\n # 1) build graph here (TF functional code pattern)\n build_model(name=self.name,\n trainable=trainable,\n objectives=self.objectives,\n features=self.features,\n feature_index2words=self.feature_index2words,\n hidden_sizes=self.hidden_sizes,\n keep_prob=self.keep_prob,\n solver=self.solver,\n freeze_rate=freeze_rate,\n class_weights_normalize=self.class_weights_normalize,\n class_weights=self.class_weights,\n class_weights_clipval=self.class_weights_clipval,\n freeze_rate_anneal=freeze_rate_anneal,\n cudnn=self.cudnn,\n lr=self.lr,\n fused=self.fused,\n weight_noise=self.weight_noise,\n anneal_rate=self.anneal_rate,\n input_keep_prob=self.input_keep_prob,\n faux_cudnn=faux_cudnn,\n clip_norm=self.clip_norm)\n\n # 2) and use meta graph to recover these fields:\n self.recover_graph_variables()\n\n\n def recover_graph_variables(self):\n \"\"\"Use TF meta graph to obtain key metrics\n and outputs from model.\"\"\"\n self.labels = tf.get_collection(LABEL_PLACEHOLDERS)\n self.labels_mask = tf.get_collection(LABEL_MASK_PLACEHOLDERS)\n self.input_placeholders = tf.get_collection(INPUT_PLACEHOLDERS)\n self.sequence_lengths = tf.get_collection(SEQUENCE_LENGTHS)[0]\n self.decoded = tf.get_collection(DECODED)\n self.decoded_scores = tf.get_collection(DECODED_SCORES)\n self.unary_scores = tf.get_collection(UNARY_SCORES)\n\n self.token_correct = tf.get_collection(TOKEN_CORRECT)\n self.token_correct_total = tf.get_collection(TOKEN_CORRECT_TOTAL)\n\n self.sentence_correct = tf.get_collection(SENTENCE_CORRECT)\n self.sentence_correct_total = tf.get_collection(SENTENCE_CORRECT_TOTAL)\n\n self.token_correct_all = tf.get_collection(TOKEN_CORRECT_ALL)[0]\n self.token_correct_all_total = tf.get_collection(TOKEN_CORRECT_ALL_TOTAL)[0]\n self.sentence_correct_all = tf.get_collection(SENTENCE_CORRECT_ALL)[0]\n self.sentence_correct_all_total = tf.get_collection(SENTENCE_CORRECT_ALL_TOTAL)[0]\n\n self.true_positives = tf.get_collection(TRUE_POSITIVES)\n self.false_positives = tf.get_collection(FALSE_POSITIVES)\n self.false_negatives = tf.get_collection(FALSE_NEGATIVES)\n\n if len(self.true_positives) == 0 and len(self.token_correct) != 0:\n self.true_positives = [None for _ in self.token_correct]\n self.false_positives = [None for _ in self.token_correct]\n self.false_negatives = [None for _ in self.token_correct]\n\n if len(tf.get_collection(GLOBAL_STEP)) > 0:\n self.global_step = tf.get_collection(GLOBAL_STEP)[0]\n else:\n try:\n self.global_step = tf.get_default_graph().get_tensor_by_name(\n self.name + \"/\" + \"global_step:0\")\n except KeyError:\n self.global_step = tf.Variable(0, trainable=False, name=\"global_step\")\n tf.add_to_collection(GLOBAL_STEP, self.global_step)\n\n self.is_training = tf.get_collection(IS_TRAINING)[0]\n self.noop = tf.no_op()\n self.train_op = tf.get_collection(TRAIN_OP)[0]\n train_summaries = tf.get_collection(TRAIN_SUMMARIES)\n self.train_summaries = train_summaries[0] if len(train_summaries) > 0 else None\n\n self.nll = tf.get_collection(NLL)[0]\n self.nll_total = tf.get_collection(NLL_TOTAL)[0]\n self.saver = tf.train.Saver()\n\n\n\n @classmethod\n def overrideable_fields(cls):\n return [\n \"keep_prob\",\n \"name\",\n \"lr\",\n \"clip_norm\",\n \"class_weights_normalize\",\n \"class_weights_clipval\",\n \"cudnn\",\n \"anneal_rate\",\n \"weight_noise\",\n \"input_keep_prob\"\n ]\n\n @classmethod\n def fields_to_save(cls):\n return [\n \"hidden_sizes\",\n \"objectives\",\n \"name\",\n \"cudnn\",\n \"class_weights\",\n \"features\",\n \"fused\",\n \"class_weights_normalize\",\n \"weight_noise\",\n \"anneal_rate\",\n \"feature_index2words\",\n \"solver\",\n \"lr\",\n \"clip_norm\",\n \"keep_prob\",\n \"input_keep_prob\",\n \"class_weights_clipval\"\n ]\n\n def predict(self, session, feed_dict):\n feed_dict[self.is_training] = False\n outputs, outputs_probs = session.run(\n (self.decoded, self.decoded_scores), feed_dict\n )\n predictions_out = {}\n for value, val_prob, objective in zip(outputs, outputs_probs, self.objectives):\n predictions_out[objective[\"name\"]] = (value, val_prob)\n return predictions_out\n\n def predict_proba(self, session, feed_dict):\n feed_dict[self.is_training] = False\n outputs = session.run(\n self.unary_scores, feed_dict\n )\n predictions_out = {}\n for value, objective in zip(outputs, self.objectives):\n predictions_out[objective[\"name\"]] = value\n return predictions_out\n\n def save(self, session, path):\n makedirs(path, exist_ok=True)\n with open(join(path, \"model.json\"), \"wt\") as fout:\n save_dict = {}\n for field in type(self).fields_to_save():\n save_dict[field] = getattr(self, field)\n json.dump(save_dict, fout)\n\n with open(join(path, \"rng.pkl\"), \"wb\") as fout:\n pickle.dump(self.rng, fout)\n\n save_session(session, self.saver, path, verbose=True)\n\n @classmethod\n def load(cls, session, path, args=None, verbose=True, trainable=True,\n rebuild_graph=False, faux_cudnn=False, replace_to=None, replace_from=None):\n \"\"\"Convenience method for using a tensorflow session to reload\n a previously saved + serialized model from disk.\"\"\"\n with open(join(path, \"model.json\"), \"rt\") as fin:\n model_props = json.load(fin)\n\n # update fields based on CLI:\n if args is not None:\n ex_fields = explicitly_set_fields()\n for field in cls.overrideable_fields():\n if field in ex_fields:\n model_props[field] = getattr(args, field)\n\n # prune old fields based on changes to saveable fields:\n relevant_props = {}\n for field in cls.fields_to_save():\n if field in model_props:\n relevant_props[field] = model_props[field]\n\n relevant_props[\"trainable\"] = trainable\n relevant_props[\"faux_cudnn\"] = faux_cudnn\n\n if rebuild_graph:\n print(\"Using rebuild_graph mode: creating a new graph.\", flush=True)\n relevant_props[\"create_variables\"] = True\n model = cls(**relevant_props)\n restore_session(\n session, path,\n replace_to=replace_to,\n replace_from=replace_from,\n verbose=verbose,\n use_metagraph=False\n )\n else:\n if model_props.get(\"cudnn\", False):\n import tensorflow.contrib.cudnn_rnn\n relevant_props[\"create_variables\"] = False\n restore_session(\n session, path,\n verbose=verbose,\n use_metagraph=True\n )\n model = cls(**relevant_props)\n\n rng_path = join(path, \"rng.pkl\")\n if exists(rng_path):\n # apply the saved random number generator to this\n # model:\n with open(rng_path, \"rb\") as fin:\n model.rng = pickle.load(fin)\n return model\n\n\ndef make_path_absolute(obj, basepath):\n copied = obj.copy()\n for key in [\"path\", \"vocab\"]:\n if key in copied:\n copied[key] = join(basepath, copied[key])\n return copied\n\n\nclass Config(object):\n def __init__(self, datasets, features, objectives,\n wikidata_path, classification_path):\n assert(len(features) > 0)\n self.datasets = datasets\n self.features = features\n self.objectives = objectives\n self.classifications = None\n self.wikidata_path = wikidata_path\n self.classification_path = classification_path\n\n # build the objective names:\n self._named_objectives = [obj[\"name\"] for obj in self.objectives]\n\n @classmethod\n def load(cls, path):\n with open(path, \"rt\") as fin:\n config = json.load(fin)\n config_dirname = dirname(path)\n return cls(\n datasets=[make_path_absolute(dataset, config_dirname) for dataset in config['datasets']],\n features=[make_path_absolute(feat, config_dirname) for feat in config['features']],\n objectives=[make_path_absolute(objective, config_dirname) for objective in config['objectives']],\n wikidata_path=config.get(\"wikidata_path\", None),\n classification_path=(\n join(config_dirname, config.get(\"classification_path\", None))\n if \"classification_path\" in config else None)\n )\n\n def load_dataset_separate(self, dataset_type):\n paths = [dataset for dataset in self.datasets if dataset[\"type\"] == dataset_type]\n all_examples = {}\n for dataset in paths:\n _, extension = splitext(dataset[\"path\"])\n if extension == \".h5\" or extension == \".hdf5\":\n if self.classifications is None:\n if self.wikidata_path is None or self.classification_path is None:\n raise ValueError(\"missing wikidata_path and \"\n \"classification_path, cannot \"\n \"construct H5Dataset.\")\n self.classifications = ClassificationHandler(\n self.wikidata_path,\n self.classification_path\n )\n examples = H5Dataset(\n dataset[\"path\"],\n dataset[\"x\"],\n dataset[\"y\"],\n self._named_objectives,\n ignore_value=dataset.get('ignore', None),\n classifications=self.classifications)\n else:\n examples = TSVDataset(\n dataset[\"path\"],\n dataset[\"x\"],\n dataset[\"y\"],\n self._named_objectives,\n comment=dataset.get('comment', '#'),\n ignore_value=dataset.get('ignore', None),\n retokenize=dataset.get('retokenize', False))\n title = dataset[\"path\"].split('/')[-1].split(\".\")[0]\n name = title\n iteration = 1\n while name in all_examples:\n name = title + \"-%d\" % (iteration,)\n iteration += 1\n all_examples[name] = examples\n return all_examples\n\n def load_dataset(self, dataset_type, merge=True):\n datasets = self.load_dataset_separate(dataset_type)\n if merge:\n return CombinedDataset(list(datasets.values()))\n return datasets\n\n\ndef boolean_argument(parser, name, default):\n parser.add_argument(\"--\" + name, action=\"store_true\", default=default)\n parser.add_argument(\"--no\" + name, action=\"store_false\", dest=name)\n\n\ndef parse_args(args=None):\n parser = argparse.ArgumentParser()\n parser.add_argument('config', type=str)\n parser.add_argument('--lr', type=float, default=0.001)\n parser.add_argument('--anneal_rate', type=float, default=0.99)\n parser.add_argument('--clip_norm', type=float, default=-1)\n parser.add_argument('--weight_noise', type=float, default=0.0)\n parser.add_argument('--hidden_sizes', type=int, nargs=\"*\", default=[200, 200])\n parser.add_argument('--load_dir', type=str, default=None)\n parser.add_argument('--restore_input_features', type=str, default=None)\n parser.add_argument('--improvement_key', type=str, default=\"token_correct\")\n parser.add_argument('--freeze_rate', type=float, default=1.0)\n parser.add_argument('--freeze_rate_anneal', type=float, default=0.8)\n parser.add_argument('--save_dir', type=str, default=None)\n parser.add_argument('--max_epochs', type=int, default=1000)\n parser.add_argument('--test_every', type=int, default=10000,\n help=\"Number of training iterations after which testing should occur.\")\n parser.add_argument('--batch_size', type=int, default=128)\n parser.add_argument('--max_patience', type=int, default=10)\n parser.add_argument('--class_weights_clipval', type=float, default=1000.0)\n parser.add_argument('--device', type=str, default=\"gpu:0\")\n parser.add_argument('--keep_prob', type=float, default=0.5)\n parser.add_argument('--input_keep_prob', type=float, default=0.7)\n parser.add_argument('--solver', type=str, default=\"adam\",\n choices=[\"adam\", \"sgd\"])\n parser.add_argument(\"--name\", type=str, default=\"SequenceTagger\")\n parser.add_argument(\"--old_name\", type=str, default=None)\n boolean_argument(parser, \"cudnn\", True)\n boolean_argument(parser, \"faux_cudnn\", False)\n boolean_argument(parser, \"class_weights\", False)\n boolean_argument(parser, \"rebuild_graph\", False)\n boolean_argument(parser, \"class_weights_normalize\", False)\n boolean_argument(parser, \"fused\", True)\n boolean_argument(parser, \"report_metrics_per_axis\", True)\n boolean_argument(parser, \"report_class_f1\", False)\n return parser.parse_args(args=args)\n\n\ndef get_vocab(dataset, max_vocab=-1, extra_words=None):\n index2word = []\n occurrence = {}\n for el in dataset:\n if el not in occurrence:\n index2word.append(el)\n occurrence[el] = 1\n else:\n occurrence[el] += 1\n index2word = sorted(index2word, key=lambda x: occurrence[x], reverse=True)\n if max_vocab > 0:\n index2word = index2word[:max_vocab]\n if extra_words is not None:\n index2word = extra_words + index2word\n return index2word\n\n\ndef get_objectives(objectives, dataset):\n out = []\n for obj_idx, objective in enumerate(objectives):\n if \"vocab\" in objective:\n with open(objective[\"vocab\"], \"rt\") as fin:\n vocab = fin.read().splitlines()\n else:\n vocab = get_vocab((w[obj_idx] for _, y in dataset for w in y if w[obj_idx] is not None), -1)\n\n out.append(\n {\n \"vocab\": vocab,\n \"type\": objective[\"type\"],\n \"name\": objective[\"name\"]\n }\n )\n return out\n\n\ndef merge_all_metrics(metrics):\n out = {}\n for key, metric in metrics.items():\n for subkey, submetric in metric.items():\n if len(key) > 0:\n out[key + \"_\" + subkey] = submetric\n if subkey not in out:\n out[subkey] = submetric\n else:\n out[subkey] += submetric\n else:\n out[subkey] = submetric\n return out\n\n\ndef log_outcome(logger, outcome, step, name):\n for k, v in sorted(outcome.items()):\n if \"total\" in k:\n continue\n else:\n total = outcome[k + \"_total\"]\n if total == 0:\n continue\n logger.log(k, v / total, step=step)\n logger.writer.flush()\n\n\ndef compute_f1(metrics, objectives, report_class_f1):\n total_f1 = 0.0\n total_precision = 0.0\n total_recall = 0.0\n total = 0\n for objective in objectives:\n name = objective[\"name\"]\n key = \"%s_true_positives\" % (name,)\n if key not in metrics:\n continue\n tp = metrics[key]\n fp = metrics[\"%s_false_positives\" % (name,)]\n fn = metrics[\"%s_false_negatives\" % (name,)]\n del metrics[key]\n del metrics[\"%s_false_positives\" % (name,)]\n del metrics[\"%s_false_negatives\" % (name,)]\n\n\n\n precision = 1.* tp / np.maximum((tp + fp), 1e-6)\n recall = 1. * tp / np.maximum((tp + fn), 1e-6)\n f1 = 2.0 * precision * recall / np.maximum((precision + recall), 1e-6)\n\n support = tp + fn\n\n full_f1 = np.average(f1, weights=support) * 100.0\n full_recall = np.average(recall, weights=support) * 100.0\n full_precision = np.average(precision, weights=support) * 100.0\n\n total_f1 += full_f1\n total_recall += full_recall\n total_precision += full_precision\n total += 1\n if report_class_f1:\n print(\"F1 %s: %r\" % (name, full_f1))\n print(\"Name\\tF1\\tTP\\tFP\\tFN\")\n rows = zip([label for label, has_support in zip(objective[\"vocab\"],\n support > 0)\n if has_support],\n f1, tp, fp, fn)\n for val, f1_val, val_tp, val_fp, val_fn in rows:\n print(\"%s\\t%r\\t%d\\t%d\\t%d\" % (\n val, f1_val, val_tp, val_fp, val_fn))\n print(\"\")\n if total > 0:\n metrics[\"F1\"] = total_f1\n metrics[\"recall\"] = total_recall\n metrics[\"precision\"] = total_precision\n metrics[\"F1_total\"] = total\n metrics[\"recall_total\"] = total\n metrics[\"precision_total\"] = total\n\n\ndef accuracy(model, session, datasets, batch_size, train,\n report_metrics_per_axis, report_class_f1,\n callback=None,\n callback_period=None, writer=None):\n pbar = get_progress_bar(\"train\" if train else \"validation\", item=\"batches\")\n if not isinstance(datasets, dict):\n datasets = {'':datasets}\n all_metrics_agg = {}\n\n if callback is not None:\n if callback_period is None:\n raise ValueError(\"callback_period cannot be None if \"\n \"callback is used.\")\n else:\n callback_period = None\n\n if train:\n train_op = model.train_op\n else:\n train_op = model.noop\n is_training = model.is_training\n metrics = {\"nll\": model.nll, \"nll_total\": model.nll_total}\n summaries = []\n\n if not train:\n metric_iter = zip(\n model.objectives,\n model.token_correct,\n model.token_correct_total,\n model.sentence_correct,\n model.sentence_correct_total,\n model.true_positives,\n model.false_positives,\n model.false_negatives\n )\n for metric_vars in metric_iter:\n (\n objective,\n token_correct,\n token_correct_total,\n sentence_correct,\n sentence_correct_total,\n true_positives,\n false_positives,\n false_negatives\n ) = metric_vars\n name = objective[\"name\"]\n if report_metrics_per_axis:\n metrics[\"%s_token_correct\" % (name,)] = token_correct\n metrics[\"%s_token_correct_total\" % (name,)] = token_correct_total\n metrics[\"%s_sentence_correct\" % (name,)] = sentence_correct\n metrics[\"%s_sentence_correct_total\" % (name,)] = sentence_correct_total\n if true_positives is not None:\n metrics[\"%s_true_positives\" % (name,)] = true_positives\n metrics[\"%s_false_positives\" % (name,)] = false_positives\n metrics[\"%s_false_negatives\" % (name,)] = false_negatives\n metrics[\"token_correct\"] = model.token_correct_all\n metrics[\"token_correct_total\"] = model.token_correct_all_total\n metrics[\"sentence_correct\"] = model.sentence_correct_all\n metrics[\"sentence_correct_total\"] = model.sentence_correct_all_total\n summaries = []\n else:\n if writer is not None and model.train_summaries is not None:\n summaries = model.train_summaries\n\n metrics_values = [v for _, v in sorted(metrics.items())]\n metrics_names = [name for name, _ in sorted(metrics.items())]\n outputs_val = [train_op, model.global_step, summaries, metrics_values]\n for title, dataset in datasets.items():\n batches = iter_batches_single_threaded(\n model=model,\n dataset=dataset,\n batch_size=batch_size,\n train=train,\n pbar=pbar\n )\n metrics_agg = {}\n iteration = 0\n for feed_dict in batches:\n feed_dict[is_training] = train\n _, step, summary_out, outputs = session.run(outputs_val, feed_dict)\n if writer is not None:\n writer.add_summary(summary_out, step)\n for key, value in zip(metrics_names, outputs[:len(metrics_names)]):\n if key not in metrics_agg:\n metrics_agg[key] = value\n else:\n metrics_agg[key] += value\n iteration += 1\n if callback_period is not None and iteration % callback_period == 0:\n callback(iteration)\n\n if np.isnan(metrics_agg['nll']):\n print(\"loss is NaN.\", flush=True, file=sys.stderr)\n sys.exit(1)\n\n compute_f1(metrics_agg, model.objectives, report_class_f1)\n all_metrics_agg[title] = metrics_agg\n del batches\n return merge_all_metrics(all_metrics_agg)\n\n\ndef present_outcome(outcome, epoch, name):\n string_rows = []\n for k, v in sorted(outcome.items()):\n if \"total\" in k:\n continue\n else:\n total = outcome[k + \"_total\"]\n if total == 0:\n continue\n if \"correct\" in k:\n string_rows.append(\n [\n k,\n \"%.2f%%\" % (100.0 * v / total),\n \"(%d correct / %d)\" % (v, total)\n ]\n )\n else:\n string_rows.append(\n [\n k,\n \"%.3f\" % (v / total),\n \"\"\n ]\n )\n max_len_cols = [\n max(len(row[colidx]) for row in string_rows)\n for colidx in range(len(string_rows[0]))\n ] if len(string_rows) > 0 else []\n rows = []\n for row in string_rows:\n rows.append(\n \" \".join(\n [col + \" \" * (max_len_cols[colidx] - len(col))\n for colidx, col in enumerate(row)]\n )\n )\n return \"\\n\".join([\"Epoch {epoch}: {name}\".format(epoch=epoch, name=name)] + rows)\n\n\ndef print_outcome(outcome, objectives, epoch, step, name, logger=None):\n outcome_report = present_outcome(outcome, epoch, name)\n if logger is not None:\n log_outcome(logger, outcome, step, name)\n print(outcome_report)\n\n\n\nclass SequenceTagger(object):\n def __init__(self, path, device=\"gpu\", faux_cudnn=False, rebuild_graph=False):\n tf.reset_default_graph()\n session_conf = tf.ConfigProto(\n allow_soft_placement=True\n )\n self.session = tf.InteractiveSession(config=session_conf)\n with tf.device(device):\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\", UserWarning)\n self._model = SequenceModel.load(\n self.session,\n path,\n args=None,\n verbose=False,\n trainable=False,\n rebuild_graph=rebuild_graph,\n faux_cudnn=faux_cudnn\n )\n\n @property\n def objectives(self):\n return self._model.objectives\n\n def predict_proba(self, tokens):\n blank_labels = tuple(None for _ in self._model.objectives)\n batches = list(iter_batches_single_threaded(\n model=self._model,\n dataset=[\n (tokens, [blank_labels for t in tokens])\n ],\n batch_size=1,\n train=False,\n autoresize=False\n ))\n outputs = []\n batches[0][self._model.is_training] = False\n probs_out = self._model.predict_proba(\n self.session, batches[0]\n )\n return probs_out\n\n\n def predict_proba_sentences(self, sentences):\n blank_labels = tuple(None for _ in self._model.objectives)\n batches = iter_batches_single_threaded(\n model=self._model,\n dataset=[\n (sentence, [blank_labels for t in sentence])\n for sentence in sentences\n ],\n batch_size=min(256, len(sentences)),\n train=False,\n autoresize=False\n )\n for batch in batches:\n batch[self._model.is_training] = False\n yield self._model.predict_proba(\n self.session, batch\n )\n\n def predict_topk_sentences(self, sentences, k=5):\n blank_labels = tuple(None for _ in self._model.objectives)\n batches = iter_batches_single_threaded(\n model=self._model,\n dataset=[\n (sentence, [blank_labels for t in sentence])\n for sentence in sentences\n ],\n batch_size=min(256, len(sentences)),\n train=False,\n autoresize=False\n )\n for batch in batches:\n outputs = self._model.predict_proba(\n self.session, batch\n )\n named_outputs = {}\n for objective in self._model.objectives:\n obj_name = objective[\"name\"]\n tags, scores = outputs[obj_name]\n if objective[\"type\"] == \"crf\":\n named_outputs[obj_name] = [\n [(token, [objective[\"vocab\"][tag]], [score]) for token, tag in zip(tokens, tags)]\n for tokens, tags, score in zip(sentences, tags, scores)\n ]\n elif objective[\"type\"] == 'softmax':\n all_sent_scores = []\n\n for tokens, scores in zip(sentences, scores):\n sent_scores = []\n for token, token_scores in zip(tokens, scores):\n topk = np.argsort(token_scores)[::-1][:k]\n sent_scores.append(\n (\n token,\n [objective[\"vocab\"][idx] for idx in topk],\n [token_scores[idx] for idx in topk]\n )\n )\n all_sent_scores.append(sent_scores)\n named_outputs[obj_name] = all_sent_scores\n else:\n raise ValueError(\"unknown objective type %r.\" % (objective[\"type\"],))\n yield named_outputs\n\n def tag_sentences(self, sentences):\n if len(sentences) == 0:\n return {\n objective[\"name\"]: []\n for objective in self._model.objectives\n }\n blank_labels = tuple(None for _ in self._model.objectives)\n batches = list(iter_batches_single_threaded(\n self._model,\n [\n (sentence, [blank_labels for t in sentence])\n for sentence in sentences\n ],\n batch_size=min(256, len(sentences)),\n train=False,\n autoresize=False\n ))\n\n named_outputs = {}\n sentence_idx = 0\n\n for batch in batches:\n outputs = self._model.predict(self.session, batch)\n for objective in self._model.objectives:\n obj_name = objective[\"name\"]\n if obj_name not in named_outputs:\n named_outputs[obj_name] = []\n tags, scores = outputs[obj_name]\n nsentences = len(tags)\n if objective[\"type\"] == \"crf\":\n named_outputs[obj_name].extend([\n [(token, objective[\"vocab\"][tag], score) for token, tag in zip(tokens, tags)]\n for tokens, tags, score in zip(sentences[sentence_idx:sentence_idx+nsentences], tags, scores)\n ])\n elif objective[\"type\"] == 'softmax':\n named_outputs[obj_name].extend([\n [(token, objective[\"vocab\"][tag], score)\n for token, tag, score in zip(tokens, tags, scores)]\n for tokens, tags, scores in zip(sentences[sentence_idx:sentence_idx+nsentences], tags, scores)\n ])\n else:\n raise ValueError(\"unknown objective type %r.\" % (objective[\"type\"],))\n sentence_idx += nsentences\n\n return named_outputs\n\n\ndef count_number_of_parameters():\n return int(sum([np.prod(var.get_shape().as_list())\n for var in tf.trainable_variables()]))\n\n\nclass TestCallback(object):\n def __init__(self, model, session, dataset, epoch, args, logger):\n self.model = model\n self.session = session\n self.dataset = dataset\n self.epoch = epoch\n self.args = args\n self.logger = logger\n self.report_metrics_per_axis = args.report_metrics_per_axis\n self.report_class_f1 = args.report_class_f1\n\n def test(self, iteration):\n dev_outcome = accuracy(self.model, self.session, self.dataset, self.args.batch_size,\n train=False, report_metrics_per_axis=self.report_metrics_per_axis,\n report_class_f1=self.report_class_f1)\n print_outcome(dev_outcome, self.model.objectives,\n epoch=\"{}-{}\".format(self.epoch, iteration),\n step=self.session.run(self.model.global_step),\n name=\"validation\",\n logger=self.logger\n )\n if self.args.save_dir is not None:\n self.model.save(self.session, self.args.save_dir)\n\n\ndef compute_epoch(session, model, train_set,\n validation_set, test_callback, epoch,\n train_writer, test_writer,\n args):\n test_callback.epoch = epoch\n train_outcome = accuracy(model,\n session,\n train_set,\n args.batch_size,\n train=True,\n callback_period=args.test_every,\n writer=train_writer.writer if train_writer is not None else None,\n report_metrics_per_axis=args.report_metrics_per_axis,\n report_class_f1=args.report_class_f1,\n callback=test_callback.test)\n global_step = session.run(model.global_step)\n print_outcome(train_outcome,\n model.objectives,\n epoch=epoch,\n name=\"train\",\n step=global_step,\n logger=train_writer)\n dev_outcome = accuracy(\n model, session, validation_set, args.batch_size,\n train=False,\n report_metrics_per_axis=args.report_metrics_per_axis,\n report_class_f1=args.report_class_f1)\n print_outcome(dev_outcome,\n model.objectives,\n epoch=epoch,\n step=global_step,\n name=\"validation\",\n logger=test_writer)\n if args.save_dir is not None:\n model.save(session, args.save_dir)\n return dev_outcome\n\n\ndef main():\n args = parse_args()\n config = Config.load(args.config)\n validation_set = config.load_dataset(\"dev\", merge=False)\n session_conf = tf.ConfigProto(allow_soft_placement=True)\n\n with tf.Session(config=session_conf) as session, tf.device(args.device):\n if args.load_dir is not None:\n model = SequenceModel.load(session, args.load_dir,\n args=args, rebuild_graph=args.rebuild_graph, faux_cudnn=args.faux_cudnn,\n replace_to=args.name,\n replace_from=args.old_name)\n dev_outcome = accuracy(\n model, session, validation_set, args.batch_size, train=False,\n report_metrics_per_axis=args.report_metrics_per_axis,\n report_class_f1=args.report_class_f1)\n print_outcome(dev_outcome,\n model.objectives, 0,\n name=\"loaded validation\",\n step=session.run(model.global_step),\n logger=None)\n # dev_outcome = None\n if args.rebuild_graph and args.save_dir is not None:\n model.save(session, args.save_dir)\n train_set = config.load_dataset(\"train\")\n else:\n # load classes and index2word from a file.\n dev_outcome = None\n train_set = config.load_dataset(\"train\")\n model = SequenceModel(\n objectives=get_objectives(config.objectives, train_set),\n features=config.features,\n feature_index2words=get_feature_vocabs(config.features, train_set, [\"\"]),\n lr=args.lr,\n anneal_rate=args.anneal_rate,\n weight_noise=args.weight_noise,\n freeze_rate=args.freeze_rate,\n freeze_rate_anneal=args.freeze_rate_anneal,\n clip_norm=args.clip_norm,\n hidden_sizes=args.hidden_sizes,\n solver=args.solver,\n fused=args.fused,\n class_weights_normalize=args.class_weights_normalize,\n class_weights=args.class_weights,\n class_weights_clipval=args.class_weights_clipval,\n keep_prob=args.keep_prob,\n input_keep_prob=args.input_keep_prob,\n name=args.name,\n cudnn=args.cudnn,\n faux_cudnn=args.faux_cudnn,\n create_variables=True)\n session.run(tf.global_variables_initializer())\n if args.restore_input_features is not None:\n restore_session(\n session, args.restore_input_features,\n verbose=True,\n use_metagraph=False,\n only_features=True)\n\n print(\"Model has {} trainable parameters.\".format(count_number_of_parameters()), flush=True)\n best_dev_score = 0.0\n patience = 0\n best_epoch = 0\n best_outcome = None\n improvement_key = args.improvement_key\n if dev_outcome is not None:\n best_dev_score = dev_outcome[improvement_key]\n best_epoch = -1\n best_outcome = dev_outcome\n\n if args.save_dir is not None:\n train_writer = Logger(session, tf.summary.FileWriter(join(args.save_dir, \"train\")))\n test_writer = Logger(session, tf.summary.FileWriter(join(args.save_dir, \"test\")))\n else:\n train_writer, test_writer = None, None\n\n test_callback = TestCallback(model,\n session,\n validation_set,\n -1,\n args,\n logger=test_writer)\n if len(train_set) > 0:\n train_set.set_randomize(True)\n train_set.set_rng(model.rng)\n for epoch in range(args.max_epochs):\n dev_outcome = compute_epoch(\n session, model,\n train_set=train_set, validation_set=validation_set,\n epoch=epoch, test_callback=test_callback,\n train_writer=train_writer,\n test_writer=test_writer,\n args=args)\n\n if dev_outcome[improvement_key] > best_dev_score:\n best_dev_score = dev_outcome[improvement_key]\n best_epoch = epoch\n best_outcome = dev_outcome\n patience = 0\n if args.save_dir is not None:\n model.save(session, join(args.save_dir, \"best\"))\n else:\n patience += 1\n if patience >= args.max_patience:\n print(\"No improvements for {} epochs. Stopping.\".format(args.max_patience))\n break\n del dev_outcome\n print_outcome(\n best_outcome,\n model.objectives,\n epoch=best_epoch,\n name=\"validation-best\",\n step=session.run(model.global_step),\n logger=None)\n\n\nif __name__ == \"__main__\":\n main()\n"}}},{"rowIdx":16,"cells":{"python_code":{"kind":"string","value":"import numpy as np\nimport subprocess\nimport h5py\nimport ciseau\nfrom os.path import exists, splitext, join\nfrom wikidata_linker_utils.wikidata_ids import load_wikidata_ids\n\ndef count_examples(lines, comment, ignore_value, column_indices):\n example_length = 0\n has_labels = False\n found = 0\n for line in lines:\n if len(line) == 0 or (comment is not None and line.startswith(comment)):\n if example_length > 0 and has_labels:\n found += 1\n example_length = 0\n has_labels = False\n else:\n example_length += 1\n if not has_labels:\n cols = line.split(\"\\t\")\n if len(cols) > 1:\n if ignore_value is not None:\n for col_index in column_indices:\n if cols[col_index] != ignore_value:\n has_labels = True\n break\n\n else:\n has_labels = True\n if example_length > 0 and has_labels:\n found += 1\n return found\n\n\ndef retokenize_example(x, y):\n tokens = ciseau.tokenize(\" \".join(w for w in x),\n normalize_ascii=False)\n out_y = []\n regular_cursor = 0\n tokens_length_total = 0\n regular_length_total = len(x[regular_cursor]) + 1 if len(x) > 0 else 0\n if regular_cursor + 1 == len(x):\n regular_length_total -= 1\n for i in range(len(tokens)):\n tokens_length_total = tokens_length_total + len(tokens[i])\n while regular_length_total < tokens_length_total:\n regular_cursor += 1\n regular_length_total = regular_length_total + len(x[regular_cursor]) + 1\n if regular_cursor + 1 == len(x):\n regular_length_total -= 1\n out_y.append(y[regular_cursor])\n assert(regular_cursor + 1 == len(x)), \"error with %r\" % (x,)\n return ([tok.rstrip() for tok in tokens], out_y)\n\n\ndef convert_lines_to_examples(lines, comment, ignore_value,\n column_indices, x_column, empty_column,\n retokenize=False):\n examples = []\n x = []\n y = []\n for line in lines:\n if len(line) == 0 or (comment is not None and line.startswith(comment)):\n if len(x) > 0:\n if not all(row == empty_column for row in y):\n examples.append((x, y))\n x = []\n y = []\n else:\n cols = line.split(\"\\t\")\n x.append(cols[x_column])\n if len(cols) == 1:\n y.append(empty_column)\n else:\n if ignore_value is not None:\n y.append(\n tuple(\n cols[col_index] if col_index is not None and cols[col_index] != ignore_value else None\n for col_index in column_indices\n )\n )\n else:\n y.append(\n tuple(\n cols[col_index] if col_index is not None else None\n for col_index in column_indices\n )\n )\n if len(x) > 0 and not all(row == empty_column for row in y):\n examples.append((x, y))\n if retokenize:\n examples = [retokenize_example(x, y) for x, y in examples]\n return examples\n\n\ndef load_tsv(path, x_column, y_columns, objective_names, comment, ignore_value,\n retokenize):\n \"\"\"\"\n Deprecated method for loading a tsv file as a training/test set for a model.\n\n Arguments:\n ----------\n path: str, location of tsv file\n x_column: int\n y_columns: list, objectives in this file along with their column.\n (e.g. `y_columns=[{\"objective\": \"POS\", \"column\": 2}, ...])`)\n objective_names: name of all desired columns\n comment: line beginning indicating it's okay to skip\n ignore_value: label value that should be treated as missing\n retokenize: run tokenizer again.\n Returns\n -------\n list : examples loaded into memory\n\n Note: can use a lot of memory since entire file is loaded.\n \"\"\"\n objective2column = {col['objective']: col['column'] for col in y_columns}\n column_indices = [objective2column.get(name, None) for name in objective_names]\n empty_column = tuple(None for _ in objective_names)\n\n if all(col_index is None for col_index in column_indices):\n return []\n\n with open(path, \"rt\") as fin:\n lines = fin.read().splitlines()\n\n return convert_lines_to_examples(lines,\n ignore_value=ignore_value,\n empty_column=empty_column,\n x_column=x_column,\n column_indices=column_indices,\n comment=comment,\n retokenize=retokenize)\n\n\nclass RandomizableDataset(object):\n def set_rng(self, rng):\n self.rng = rng\n\n def set_randomize(self, randomize):\n self.randomize = randomize\n\n def set_ignore_y(self, ignore):\n self.ignore_y = ignore\n\nclass TSVDataset(RandomizableDataset):\n _fhandle = None\n _fhandle_position = 0\n _examples = None\n _example_indices = None\n _example_index = 0\n _eof = False\n ignore_y = False\n def __init__(self, path, x_column, y_columns, objective_names, comment, ignore_value,\n retokenize=False, chunksize=50000000, randomize=False, rng=None):\n \"\"\"\"\n Arguments:\n ----------\n path: str, location of tsv file\n x_column: int\n y_columns: list, objectives in this file along with their column.\n (e.g. `y_columns=[{\"objective\": \"POS\", \"column\": 2}, ...])`)\n objective_names: name of all desired columns\n comment: line beginning indicating it's okay to skip\n ignore_value: label value that should be treated as missing\n chunksize: how many bytes to read from the file at a time.\n rng: numpy RandomState\n retokenize: run tokenizer on x again.\n \"\"\"\n self.path = path\n self.randomize = randomize\n self.x_column = x_column\n self.y_columns = y_columns\n self.objective_names = objective_names\n self.comment = comment\n self.ignore_value = ignore_value\n self.retokenize = retokenize\n self.chunksize = chunksize\n if rng is None:\n rng = np.random.RandomState(0)\n self.rng = rng\n # column picking setup:\n objective2column = {col['objective']: col['column'] for col in y_columns}\n self.column_indices = [objective2column.get(name, None) for name in objective_names]\n self.empty_column = tuple(None for _ in objective_names)\n if all(col_index is None for col_index in self.column_indices):\n self.length = 0\n else:\n self._compute_length()\n\n def _signature(self):\n try:\n file_sha1sum = subprocess.check_output(\n [\"sha1sum\", self.path], universal_newlines=True\n ).split(\" \")[0]\n except FileNotFoundError:\n file_sha1sum = subprocess.check_output(\n [\"shasum\", self.path], universal_newlines=True\n ).split(\" \")[0]\n sorted_cols = list(\n map(\n str,\n sorted(\n [col for col in self.column_indices if col is not None]\n )\n )\n )\n return \"-\".join([file_sha1sum] + sorted_cols)\n\n def _compute_length(self):\n length_file = (\n splitext(self.path)[0] +\n \"-length-\" +\n self._signature() + \".txt\"\n )\n if exists(length_file):\n with open(length_file, \"rt\") as fin:\n total = int(fin.read())\n else:\n total = 0\n while True:\n total += self._count_examples()\n if self._eof:\n break\n with open(length_file, \"wt\") as fout:\n fout.write(str(total) + \"\\n\")\n self.length = total\n\n def __len__(self):\n return self.length\n\n def close(self):\n if self._fhandle is not None:\n self._fhandle.close()\n self._fhandle = None\n self._fhandle_position = 0\n self._eof = False\n self._examples = None\n self._example_indices = None\n\n def __del__(self):\n self.close()\n\n def _read_file_until_newline(self):\n if self._fhandle is None:\n self._fhandle = open(self.path, \"rb\")\n if self._eof:\n self._fhandle_position = 0\n self._fhandle.seek(0)\n self._eof = False\n\n read_chunk = None\n while True:\n new_read_chunk = self._fhandle.read(self.chunksize)\n if read_chunk is None:\n read_chunk = new_read_chunk\n else:\n read_chunk += new_read_chunk\n if len(new_read_chunk) < self.chunksize:\n del new_read_chunk\n self._fhandle_position += len(read_chunk)\n self._eof = True\n break\n else:\n del new_read_chunk\n newline_pos = read_chunk.rfind(b\"\\n\\n\")\n if newline_pos != -1:\n # move to last line end position (so that we don't get\n # half an example.)\n self._fhandle.seek(self._fhandle_position + newline_pos + 2)\n self._fhandle_position += newline_pos + 2\n read_chunk = read_chunk[:newline_pos]\n break\n return read_chunk\n\n def _count_examples(self):\n read_chunk = self._read_file_until_newline()\n return count_examples(\n read_chunk.decode(\"utf-8\").splitlines(),\n ignore_value=self.ignore_value,\n column_indices=self.column_indices,\n comment=self.comment\n )\n\n def _load_examples(self):\n read_chunk = self._read_file_until_newline()\n if self._examples is not None:\n del self._examples\n self._examples = convert_lines_to_examples(\n read_chunk.decode(\"utf-8\").splitlines(),\n ignore_value=self.ignore_value,\n empty_column=self.empty_column,\n x_column=self.x_column,\n column_indices=self.column_indices,\n comment=self.comment,\n retokenize=self.retokenize\n )\n self._example_indices = np.arange(len(self._examples))\n if self.randomize:\n # access loaded data randomly:\n self.rng.shuffle(self._example_indices)\n self._example_index = 0\n\n def __getitem__(self, index):\n \"\"\"Retrieve the next example (index is ignored)\"\"\"\n if index >= self.length:\n raise StopIteration()\n if self._example_indices is None or self._example_index == len(self._example_indices):\n self._load_examples()\n while len(self._examples) == 0:\n self._load_examples()\n if len(self._examples) > 0:\n break\n if self._eof:\n raise StopIteration()\n ex = self._examples[self._example_indices[self._example_index]]\n self._example_index += 1\n return ex\n\n def set_randomize(self, randomize):\n if randomize != self.randomize:\n self.randomize = randomize\n\n def close(self):\n if self._fhandle is not None:\n self._fhandle.close()\n self._fhandle = None\n\n\nclass OracleClassification(object):\n def __init__(self, classes, classification, path):\n self.classes = classes\n self.classification = classification\n self.path = path\n self.contains_other = self.classes[-1] == \"other\"\n\n def classify(self, index):\n return self.classification[index]\n\ndef load_oracle_classification(path):\n with open(join(path, \"classes.txt\"), \"rt\", encoding=\"UTF-8\") as fin:\n classes = fin.read().splitlines()\n classification = np.load(join(path, \"classification.npy\"))\n return OracleClassification(classes, classification, path)\n\n\n\nclass ClassificationHandler(object):\n def __init__(self, wikidata_path, classification_path):\n self.classification_path = classification_path\n _, self.name2index = load_wikidata_ids(wikidata_path, verbose=False)\n self.classifiers = {}\n\n def get_classifier(self, name):\n if name not in self.classifiers:\n self.classifiers[name] = load_oracle_classification(\n join(self.classification_path, name)\n )\n return self.classifiers[name]\n\n\nclass H5Dataset(RandomizableDataset):\n handle_open = False\n ignore_y = False\n _max_generated_example = 0\n _min_generated_example = 0\n def __init__(self, path, x_column, y_columns, objective_names,\n classifications, ignore_value, randomize=False, rng=None):\n self.x_column = str(x_column)\n self.y_columns = y_columns\n self.ignore_value = ignore_value\n self.objective_names = objective_names\n self.randomize = randomize\n if rng is None:\n rng = np.random.RandomState(0)\n self.rng = rng\n self._classifications = classifications\n self.handle = h5py.File(path, \"r\")\n self.path = path\n self.handle_open = True\n self.length = len(self.handle[self.x_column])\n self.chunksize = self.handle[self.x_column].chunks[0]\n self._example_indices = None\n objective2column = {\n col['objective']: (\n str(col['column']),\n self._classifications.get_classifier(col['classification'])\n ) for col in y_columns\n }\n if self.ignore_value is not None:\n for _, classifier in objective2column.values():\n if self.ignore_value in classifier.classes:\n classifier.classes[classifier.classes.index(self.ignore_value)] = None\n\n self.column2col_indices = {}\n for col_idx, name in enumerate(self.objective_names):\n if name not in objective2column:\n continue\n column, classifier = objective2column[name]\n if column not in self.column2col_indices:\n self.column2col_indices[column] = [(classifier, col_idx)]\n else:\n self.column2col_indices[column].append((classifier, col_idx))\n\n def close(self):\n if self.handle_open:\n self.handle.close()\n self.handle_open = False\n\n def __del__(self):\n self.close()\n\n def __len__(self):\n return self.length\n\n def _build_examples(self, index):\n x = [x_chunk.split(\"\\n\") for x_chunk in self.handle[self.x_column][index:index + self.chunksize]]\n y = [[[None for k in range(len(self.objective_names))] for j in range(len(x[i]))] for i in range(len(x))]\n if not self.ignore_y:\n for handle_column, col_content in self.column2col_indices.items():\n col_ids = [[self._classifications.name2index[name] if name != \"\" else None\n for name in y_chunk.split(\"\\n\")]\n for y_chunk in self.handle[handle_column][index:index + self.chunksize]]\n for i in range(len(col_ids)):\n for j, idx in enumerate(col_ids[i]):\n if idx is not None:\n for classifier, k in col_content:\n y[i][j][k] = classifier.classify(idx)\n\n return x, y\n\n def set_randomize(self, randomize):\n if self.randomize != randomize:\n self.randomize = randomize\n if self._max_generated_example != self._min_generated_example:\n self.xorder = np.arange(self._min_generated_example, self._max_generated_example)\n self.rng.shuffle(self.xorder)\n\n\n def __getitem__(self, index):\n if index >= len(self):\n raise StopIteration()\n if self.randomize:\n if self._example_indices is None or index == 0:\n self._example_indices = np.arange(0, len(self), self.chunksize)\n self.rng.shuffle(self._example_indices)\n # transformed index:\n index = (self._example_indices[index // self.chunksize] + (index % self.chunksize)) % len(self)\n\n if index < self._min_generated_example or index >= self._max_generated_example:\n self.x, self.y = self._build_examples(index)\n # store bounds of generated data:\n self._min_generated_example = index\n self._max_generated_example = index + len(self.x)\n\n if self.randomize:\n self.xorder = np.arange(self._min_generated_example, self._max_generated_example)\n self.rng.shuffle(self.xorder)\n if self.randomize:\n index = self.xorder[index - self._min_generated_example]\n return self.x[index - self._min_generated_example], self.y[index - self._min_generated_example]\n\nclass CombinedDataset(object):\n _which_dataset = None\n _dataset_counters = None\n def set_rng(self, rng):\n self.rng = rng\n for dataset in self.datasets:\n dataset.rng = rng\n\n def set_randomize(self, randomize):\n self.randomize = randomize\n for dataset in self.datasets:\n dataset.set_randomize(randomize)\n\n def set_ignore_y(self, ignore):\n for dataset in self.datasets:\n dataset.set_ignore_y(ignore)\n\n def close(self):\n for dataset in self.datasets:\n dataset.close()\n\n def _build_which_dataset(self):\n self._which_dataset = np.empty(self.length, dtype=np.int16)\n self._dataset_counters = np.zeros(len(self.datasets), dtype=np.int64)\n offset = 0\n for index, dataset in enumerate(self.datasets):\n # ensure each dataset is seen as much as its content\n # says:\n self._which_dataset[offset:offset + len(dataset)] = index\n offset += len(dataset)\n\n def __getitem__(self, index):\n if index == 0:\n if self.randomize:\n # visit datasets in random orders:\n self.rng.shuffle(self._which_dataset)\n self._dataset_counters[:] = 0\n which = self._which_dataset[index]\n idx = self._dataset_counters[which]\n self._dataset_counters[which] += 1\n return self.datasets[which][idx]\n\n def __init__(self, datasets, rng=None, randomize=False):\n self.datasets = datasets\n if rng is None:\n rng = np.random.RandomState(0)\n self.set_rng(rng)\n self.set_randomize(randomize)\n self.length = sum(len(dataset) for dataset in datasets)\n self._build_which_dataset()\n\n def __len__(self):\n return self.length\n"}}},{"rowIdx":17,"cells":{"python_code":{"kind":"string","value":"import queue\nimport threading\n\n\ndef prefetch_generator(generator, to_fetch=10):\n q = queue.Queue(maxsize=to_fetch)\n\n def thread_worker(queue, gen):\n for val in gen:\n queue.put(val)\n queue.put(None)\n\n t = threading.Thread(target=thread_worker, args=(q, generator))\n some_exception = None\n try:\n t.start()\n while True:\n job = q.get()\n if job is None:\n break\n yield job\n del job\n # print(\"q.qsize() %d\" % (q.qsize(),), flush=True)\n except Exception as e:\n some_exception = e\n finally:\n if some_exception is not None:\n raise some_exception\n t.join()\n del t\n"}}},{"rowIdx":18,"cells":{"python_code":{"kind":"string","value":"\"\"\"\nObtain a learnability score for each type axis.\nTrains a binary classifier for each type and\ngets its AUC.\n\nUsage\n-----\n\n```\npython3 evaluate_learnability.py sample_data.tsv --out report.json --wikidata /path/to/wikidata\n```\n\n\"\"\"\nimport json\nimport time\nimport argparse\n\nfrom os.path import dirname, realpath, join\n\nSCRIPT_DIR = dirname(realpath(__file__))\n\nimport numpy as np\nimport tensorflow as tf\n\nfrom sklearn import metrics\nfrom collections import Counter\n\nfrom wikidata_linker_utils.type_collection import TypeCollection, offset_values_mask\nimport wikidata_linker_utils.wikidata_properties as wprop\nfrom wikidata_linker_utils.progressbar import get_progress_bar\nfrom generator import prefetch_generator\n\n\ndef learnability(collection, lines, mask, truth_tables, qids, id2pos,\n epochs=5, batch_size=128, max_dataset_size=-1,\n max_vocab_size=10000, hidden_sizes=None, lr=0.001,\n window_size=5, input_size=5, keep_prob=0.5,\n verbose=True):\n if hidden_sizes is None:\n hidden_sizes = []\n tf.reset_default_graph()\n dset = list(get_windows(lines, mask, window_size, truth_tables, lambda x: id2pos[x]))\n if max_dataset_size > 0:\n dset = dset[:max_dataset_size]\n\n pos_num = np.zeros(len(qids))\n for _, labels in dset:\n pos_num += labels\n neg_num = np.ones(len(qids)) * len(dset) - pos_num\n pos_weight = (pos_num / (pos_num + neg_num))[None, :]\n\n vocab = [\"\"] + [w for w, _ in Counter(lines[:, 0]).most_common(max_vocab_size)]\n inv_vocab = {w: k for k, w in enumerate(vocab)}\n with tf.device(\"gpu\"):\n W = tf.get_variable(\n \"W\", shape=[len(vocab), input_size],\n dtype=tf.float32,\n initializer=tf.random_normal_initializer()\n )\n indices = tf.placeholder(tf.int32, [None, window_size*2], name=\"indices\")\n labels = tf.placeholder(tf.bool, [None, len(qids)], name=\"label\")\n keep_prob_pholder = tf.placeholder_with_default(keep_prob, [])\n lookup = tf.reshape(tf.nn.embedding_lookup(\n W, indices\n ), [tf.shape(indices)[0], input_size * window_size*2])\n lookup = tf.nn.dropout(lookup, keep_prob_pholder)\n hidden = lookup\n for layer_idx, hidden_size in enumerate(hidden_sizes):\n hidden = tf.contrib.layers.fully_connected(\n hidden,\n num_outputs=hidden_size,\n scope=\"FC%d\" % (layer_idx,)\n )\n out = tf.contrib.layers.fully_connected(\n hidden,\n num_outputs=len(qids),\n activation_fn=None)\n cost = tf.nn.sigmoid_cross_entropy_with_logits(logits=out, labels=tf.cast(labels, tf.float32))\n cost = tf.where(tf.is_finite(cost), cost, tf.zeros_like(cost))\n cost_mean = tf.reduce_mean(\n (tf.cast(labels, tf.float32) * 1.0 / (pos_weight)) * cost +\n (tf.cast(tf.logical_not(labels), tf.float32) * 1.0 / (1.0 - pos_weight)) * cost\n )\n cost_sum = tf.reduce_sum(cost)\n size = tf.shape(indices)[0]\n noop = tf.no_op()\n correct = tf.reduce_sum(tf.cast(tf.equal(tf.greater_equal(out, 0), labels), tf.int32), 0)\n out_activated = tf.sigmoid(out)\n train_op = tf.train.AdamOptimizer(learning_rate=lr).minimize(cost_mean)\n session = tf.InteractiveSession()\n session.run(tf.global_variables_initializer())\n\n def accuracy(dataset, batch_size, train):\n epoch_correct = np.zeros(len(qids))\n epoch_nll = 0.0\n epoch_total = np.zeros(len(qids))\n op = train_op if train else noop\n all_labels = []\n all_preds = []\n for i in get_progress_bar(\"train\" if train else \"dev\", item=\"batches\")(range(0, len(dataset), batch_size)):\n batch_labels = [label for _, label in dataset[i:i+batch_size]]\n csum, corr, num_examples, preds, _ = session.run([cost_sum, correct, size, out_activated, op],\n feed_dict={\n indices: [[inv_vocab.get(w, 0) for w in window] for window, _ in dataset[i:i+batch_size]],\n labels: batch_labels,\n keep_prob_pholder: keep_prob if train else 1.0\n })\n epoch_correct += corr\n epoch_nll += csum\n epoch_total += num_examples\n all_labels.extend(batch_labels)\n all_preds.append(preds)\n return (epoch_nll, epoch_correct, epoch_total, np.vstack(all_preds), np.vstack(all_labels))\n\n\n dataset_indices = np.arange(len(dset))\n train_indices = dataset_indices[:int(0.8 * len(dset))]\n dev_indices = dataset_indices[int(0.8 * len(dset)):]\n train_dataset = [dset[idx] for idx in train_indices]\n dev_dataset = [dset[idx] for idx in dev_indices]\n learnability = []\n for epoch in range(epochs):\n t0 = time.time()\n train_epoch_nll, train_epoch_correct, train_epoch_total, _, _ = accuracy(train_dataset, batch_size, train=True)\n t1 = time.time()\n if verbose:\n print(\"epoch %d train: %.3f%% in %.3fs\" % (\n epoch, 100.0 * train_epoch_correct.sum() / train_epoch_total.sum(), t1 - t0),)\n t0 = time.time()\n dev_epoch_nll, dev_epoch_correct, dev_epoch_total, pred, y = accuracy(dev_dataset, batch_size, train=False)\n t1 = time.time()\n learnability = []\n for qidx in range(len(qids)):\n try:\n fpr, tpr, thresholds = metrics.roc_curve(y[:,qidx], pred[:,qidx], pos_label=1)\n auc = metrics.auc(fpr, tpr)\n if not np.isnan(auc):\n average_precision_score = metrics.average_precision_score(y[:,qidx], pred[:,qidx])\n learnability.append((qids[qidx],\n auc,\n average_precision_score,\n 100.0 * dev_epoch_correct[qidx] / dev_epoch_total[qidx],\n int(pos_num[qidx]),\n int(neg_num[qidx])))\n except ValueError:\n continue\n if verbose:\n learnability = sorted(learnability, key=lambda x: x[1], reverse=True)\n print(\"epoch %d dev: %.3fs\" % (epoch, t1-t0))\n for qid, auc, average_precision_score, acc, pos, neg in learnability:\n print(\" %r AUC: %.3f, APS: %.3f, %.3f%% positive: %d, negative: %d\" % (\n collection.ids[qid], auc, average_precision_score, acc, pos, neg))\n print(\"\")\n return learnability\n\n\ndef generate_training_data(collection, path):\n with open(path, \"rt\") as fin:\n lines = [row.split(\"\\t\")[:2] for row in fin.read().splitlines()]\n lines_arr = np.zeros((len(lines), 2), dtype=np.object)\n mask = np.zeros(len(lines), dtype=np.bool)\n for i, l in enumerate(lines):\n lines_arr[i, 0] = l[0]\n if len(l) > 1:\n lines_arr[i, 1] = collection.name2index[l[1]]\n mask[i] = True\n return lines_arr, mask\n\n\ndef get_proposal_sets(collection, article_ids, seed):\n np.random.seed(seed)\n relation = collection.relation(wprop.CATEGORY_LINK)\n\n relation_mask = offset_values_mask(relation.values, relation.offsets, article_ids)\n counts = np.bincount(relation.values[relation_mask])\n is_fp = collection.relation(wprop.FIXED_POINTS).edges() > 0\n is_fp = is_fp[:counts.shape[0]]\n counts = counts * is_fp\n topfields_fp = np.argsort(counts)[::-1][:(counts > 0).sum()]\n relation = collection.relation(wprop.INSTANCE_OF)\n\n relation_mask = offset_values_mask(relation.values, relation.offsets, article_ids)\n counts = np.bincount(relation.values[relation_mask])\n topfields_instance_of = np.argsort(counts)[::-1][:(counts > 0).sum()]\n\n np.random.shuffle(topfields_instance_of)\n np.random.shuffle(topfields_fp)\n\n return [(topfields_instance_of, wprop.INSTANCE_OF), (topfields_fp, wprop.CATEGORY_LINK)] \n\n\ndef build_truth_tables(collection, lines, qids, relation_name):\n truth_tables = []\n all_ids = list(sorted(set(lines[:, 1])))\n id2pos = {idx: pos for pos, idx in enumerate(all_ids)}\n for qid in qids:\n truth_tables.append(collection.satisfy([relation_name], [qid])[all_ids])\n collection.reset_cache()\n truth_tables = np.stack(truth_tables, axis=1)\n qid_sums = truth_tables.sum(axis=0)\n kept_qids = []\n kept_dims = []\n for i, (qid, qid_sum) in enumerate(zip(qids, qid_sums)):\n if qid_sum != 0 and qid_sum != truth_tables.shape[0]:\n kept_qids.append(qid)\n kept_dims.append(i)\n truth_tables = truth_tables[:, kept_dims]\n return truth_tables, kept_qids, id2pos\n\n\ndef get_windows(lines, mask, window, truth_table, id_mapper):\n for i in np.where(mask)[0]:\n if i >= window and i < len(lines) - window:\n yield (lines[max(0, i - window):i + window, 0],\n truth_table[id_mapper(lines[i, 1])])\n\n\ndef parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--dataset\", type=str, required=True)\n parser.add_argument(\"--batch_size\", type=int, default=128)\n parser.add_argument(\"--seed\", type=int, default=0)\n parser.add_argument(\"--max_epochs\", type=int, default=2)\n parser.add_argument(\"--max_vocab_size\", type=int, default=10000)\n parser.add_argument(\"--simultaneous_fields\", type=int, default=512)\n parser.add_argument(\"--window_size\", type=int, default=5)\n parser.add_argument(\"--input_size\", type=int, default=5)\n parser.add_argument(\"--wikidata\", type=str, required=True)\n parser.add_argument(\"--out\", type=str, required=True)\n return parser.parse_args()\n\n\ndef generate_truth_tables(collection, lines_arr, proposal_sets, simultaneous_fields):\n for topfields, relation_name in proposal_sets:\n for i in range(0, len(topfields), simultaneous_fields):\n truth_tables, qids, id2pos = build_truth_tables(\n collection,\n lines_arr,\n qids=topfields[i:i+simultaneous_fields],\n relation_name=relation_name)\n yield (topfields[i:i+simultaneous_fields],\n relation_name,\n truth_tables,\n qids,\n id2pos)\n\n\ndef main():\n args = parse_args()\n collection = TypeCollection(args.wikidata, num_names_to_load=0)\n collection.load_blacklist(join(dirname(SCRIPT_DIR), \"extraction\", \"blacklist.json\"))\n lines_arr, mask = generate_training_data(collection, args.dataset)\n article_ids = np.array(list(set(lines_arr[:, 1])), dtype=np.int32)\n proposal_sets = get_proposal_sets(collection, article_ids, args.seed)\n report = []\n total = sum(len(topfields) for topfields, _ in proposal_sets)\n seen = 0\n t0 = time.time()\n data_source = generate_truth_tables(collection, lines_arr, proposal_sets,\n args.simultaneous_fields)\n\n for topfields, relation_name, truth_tables, qids, id2pos in prefetch_generator(data_source):\n # for each of these properties and given relation\n # construct the truth table for each item and discover\n # their 'learnability':\n seen += len(topfields)\n field_auc_scores = learnability(\n collection,\n lines_arr,\n mask,\n qids=qids,\n truth_tables=truth_tables,\n id2pos=id2pos,\n batch_size=args.batch_size,\n epochs=args.max_epochs,\n input_size=args.input_size,\n window_size=args.window_size,\n max_vocab_size=args.max_vocab_size,\n verbose=True)\n for qid, auc, average_precision_score, correct, pos, neg in field_auc_scores:\n report.append(\n {\n \"qid\": collection.ids[qid],\n \"auc\": auc,\n \"average_precision_score\": average_precision_score,\n \"correct\": correct,\n \"relation\": relation_name,\n \"positive\": pos,\n \"negative\": neg\n }\n )\n with open(args.out, \"wt\") as fout:\n json.dump(report, fout)\n t1 = time.time()\n speed = seen / (t1 - t0)\n print(\"AUC obtained for %d / %d items (%.3f items/s)\" % (seen, total, speed), flush=True)\n\n\nif __name__ == \"__main__\":\n main()\n\n"}}},{"rowIdx":19,"cells":{"python_code":{"kind":"string","value":"import numpy as np\nimport string\nfrom dataset import TSVDataset, H5Dataset, CombinedDataset\nfrom generator import prefetch_generator\n\ndef word_dropout(inputs, rng, keep_prob):\n inputs_ndim = inputs.ndim\n mask_shape = [len(inputs)] + [1] * (inputs_ndim - 1)\n return (\n inputs *\n (\n rng.random_sample(size=mask_shape) <\n keep_prob\n )\n ).astype(inputs.dtype)\n\n\ndef extract_feat(feat):\n if feat[\"type\"] == \"word\":\n return lambda x: x\n elif feat[\"type\"] == \"suffix\":\n length = feat[\"length\"]\n return lambda x: x[-length:]\n elif feat[\"type\"] == \"prefix\":\n length = feat[\"length\"]\n return lambda x: x[:length]\n elif feat[\"type\"] == \"digit\":\n return lambda x: x.isdigit()\n elif feat[\"type\"] == \"punctuation_count\":\n return lambda x: sum(c in string.punctuation for c in x)\n elif feat[\"type\"] == \"uppercase\":\n return lambda x: len(x) > 0 and x[0].isupper()\n elif feat[\"type\"] == \"character-conv\":\n max_size = feat[\"max_word_length\"]\n def extract(x):\n x_bytes = x.encode(\"utf-8\")\n if len(x_bytes) > max_size:\n return np.concatenate(\n [\n [255],\n list(x_bytes[:max_size]),\n [256]\n ]\n )\n else:\n return np.concatenate(\n [\n [255],\n list(x_bytes),\n [256],\n -np.ones(max_size - len(x_bytes), dtype=np.int32),\n ]\n )\n return extract\n else:\n raise ValueError(\"unknown feature %r.\" % (feat,))\n\n\ndef extract_word_keep_prob(feat):\n return feat.get(\"word_keep_prob\", 0.85)\n\n\ndef extract_case_keep_prob(feat):\n return feat.get(\"case_keep_prob\", 0.95)\n\n\ndef extract_s_keep_prob(feat):\n return feat.get(\"s_keep_prob\", 0.95)\n\n\ndef apply_case_s_keep_prob(feat, rng, keep_case, keep_s):\n if len(feat) == 0:\n return feat\n if keep_case < 1 and feat[0].isupper() and rng.random_sample() >= keep_case:\n feat = feat.lower()\n if keep_s < 1 and feat.endswith(\"s\") and rng.random_sample() >= keep_s:\n feat = feat[:-1]\n return feat\n\n\ndef requires_character_convolution(feat):\n return feat[\"type\"] in {\"character-conv\"}\n\n\ndef requires_vocab(feat):\n return feat[\"type\"] in {\"word\", \"suffix\", \"prefix\"}\n\n\ndef feature_npdtype(feat):\n if requires_vocab(feat):\n return np.int32\n elif feat[\"type\"] in {\"digit\", \"punctuation_count\", \"uppercase\"}:\n return np.float32\n elif requires_character_convolution(feat):\n return np.int32\n else:\n raise ValueError(\"unknown feature %r.\" % (feat,))\n\n\ndef get_vocabs(dataset, max_vocabs, extra_words=None):\n index2words = [[] for i in range(len(max_vocabs))]\n occurrences = [{} for i in range(len(max_vocabs))]\n for els in dataset:\n for el, index2word, occurrence in zip(els, index2words, occurrences):\n if el not in occurrence:\n index2word.append(el)\n occurrence[el] = 1\n else:\n occurrence[el] += 1\n index2words = [\n sorted(index2word, key=lambda x: occurrence[x], reverse=True)\n for index2word, occurrence in zip(index2words, occurrences)\n ]\n index2words = [\n index2word[:max_vocab] if max_vocab > 0 else index2word\n for index2word, max_vocab in zip(index2words, max_vocabs)\n ]\n if extra_words is not None:\n index2words = [\n extra_words + index2word for index2word in index2words\n ]\n return index2words\n\n\ndef get_feature_vocabs(features, dataset, extra_words=None):\n out, feats_needing_vocab, feats_with_vocabs, vocabs = [], [], [], []\n if hasattr(dataset, \"set_ignore_y\"):\n dataset.set_ignore_y(True)\n try:\n for feat in features:\n if requires_vocab(feat):\n if feat.get(\"path\") is not None:\n with open(feat[\"path\"], \"rt\") as fin:\n index2word = fin.read().splitlines()\n if feat.get(\"max_vocab\", -1) > 0:\n index2word = index2word[:feat[\"max_vocab\"]]\n if extra_words is not None:\n index2word = extra_words + index2word\n feats_with_vocabs.append(index2word)\n else:\n feats_needing_vocab.append(feat)\n if len(feats_needing_vocab) > 0:\n extractors = tuple(\n [extract_feat(feat) for feat in feats_needing_vocab]\n )\n vocabs = get_vocabs(\n ((extractor(w) for extractor in extractors)\n for x, _ in dataset for w in x),\n max_vocabs=[feat.get(\"max_vocab\", -1) for feat in feats_needing_vocab],\n extra_words=extra_words\n )\n vocab_feature_idx = 0\n preexisting_vocab_feature_idx = 0\n for feat in features:\n if requires_vocab(feat):\n if feat.get(\"path\") is not None:\n out.append(feats_with_vocabs[preexisting_vocab_feature_idx])\n preexisting_vocab_feature_idx += 1\n else:\n out.append(vocabs[vocab_feature_idx])\n vocab_feature_idx+=1\n else:\n out.append(None)\n finally:\n if hasattr(dataset, \"set_ignore_y\"):\n dataset.set_ignore_y(False)\n return out\n\n\ndef pad_arrays_into_array(arrays, padding):\n out_ndim = arrays[0].ndim + 1\n out_shape = [0] * out_ndim\n out_shape[0] = len(arrays)\n for arr in arrays:\n for dim_idx in range(arr.ndim):\n out_shape[1 + dim_idx] = max(out_shape[1 + dim_idx], arr.shape[dim_idx])\n out = np.empty(out_shape, dtype=arrays[0].dtype)\n out.fill(padding)\n for arr_idx, array in enumerate(arrays):\n arr_slice = [arr_idx]\n for dim_idx in range(arr.ndim):\n arr_slice.append(slice(0, array.shape[dim_idx]))\n arr_slice = tuple(arr_slice)\n out[arr_slice] = array\n return out\n\n\ndef build_objective_mask(label_sequence, objective_idx, objective_type):\n if objective_type == 'crf':\n if len(label_sequence) == 0 or label_sequence[0][objective_idx] is None:\n return np.array(False, dtype=np.bool)\n else:\n return np.array(True, dtype=np.bool)\n elif objective_type == 'softmax':\n return np.array(\n [w[objective_idx] is not None for w in label_sequence], dtype=np.bool\n )\n else:\n raise ValueError(\n \"unknown objective type %r.\" % (objective_type,)\n )\n\n\ndef allocate_shrunk_batches(max_length, batch_size, lengths):\n typical_indices = max_length * batch_size\n i = 0\n ranges = []\n while i < len(lengths):\n j = i + 1\n current_batch_size = 1\n longest_ex = lengths[j - 1]\n while j < len(lengths) and j - i < batch_size:\n # can grow?\n new_batch_size = current_batch_size + 1\n new_j = j + 1\n if max(longest_ex, lengths[new_j - 1]) * new_batch_size < typical_indices:\n j = new_j\n longest_ex = max(longest_ex, lengths[new_j - 1])\n current_batch_size = new_batch_size\n else:\n break\n ranges.append((i, j))\n i = j\n return ranges\n\n\ndef convert_label_to_index(label, label2index):\n if label is None:\n return 0\n if isinstance(label, str):\n return label2index[label]\n return label\n\n\nclass Batchifier(object):\n def __init__(self, rng, feature_word2index, objective_types, label2index,\n fused, sequence_lengths, labels, labels_mask,\n input_placeholders, features, dataset, batch_size, train,\n autoresize=True, max_length=100):\n assert(batch_size > 0), (\n \"batch size must be strictly positive (got %r).\" % (batch_size,)\n )\n # dictionaries, strings defined by model:\n self.objective_types = objective_types\n self.label2index = label2index\n self.feature_word2index = feature_word2index\n self.rng = rng\n self.fused = fused\n\n # tf placeholders:\n self.sequence_lengths = sequence_lengths\n self.labels = labels\n self.labels_mask = labels_mask\n self.input_placeholders = input_placeholders\n\n self.dataset = dataset\n self.batch_size = batch_size\n self.train = train\n\n self.dataset_is_lazy = isinstance(dataset, (TSVDataset, H5Dataset, CombinedDataset))\n self.autoresize = autoresize\n self.max_length = max_length\n\n indices = np.arange(len(dataset))\n\n if train:\n if self.dataset_is_lazy:\n dataset.set_rng(rng)\n dataset.set_randomize(True)\n elif isinstance(dataset, list):\n rng.shuffle(indices)\n self.batch_indices = []\n if self.autoresize and not self.dataset_is_lazy:\n ranges = allocate_shrunk_batches(\n max_length=self.max_length,\n batch_size=self.batch_size,\n lengths=[len(dataset[indices[i]][0]) for i in range(len(indices))]\n )\n for i, j in ranges:\n self.batch_indices.append(indices[i:j])\n else:\n for i in range(0, len(indices), self.batch_size):\n self.batch_indices.append(indices[i:i + self.batch_size])\n self.extractors = [\n (extract_feat(feat), requires_vocab(feat), feature_npdtype(feat),\n extract_word_keep_prob(feat), extract_case_keep_prob(feat), extract_s_keep_prob(feat))\n for feat in features\n ]\n\n def generate_batch(self, examples):\n X = [[] for i in range(len(self.extractors))]\n Y = []\n Y_mask = []\n for ex, label in examples:\n for idx, (extractor, uses_vocab, dtype, word_keep_prob, case_keep_prob, s_keep_prob) in enumerate(self.extractors):\n if self.train and (case_keep_prob < 1 or s_keep_prob < 1):\n ex = [apply_case_s_keep_prob(w, self.rng, case_keep_prob, s_keep_prob) for w in ex]\n if uses_vocab:\n word_feats = np.array(\n [self.feature_word2index[idx].get(extractor(w), 0) for w in ex],\n dtype=dtype\n )\n else:\n word_feats = np.array([extractor(w) for w in ex], dtype=dtype)\n if self.train and word_keep_prob < 1:\n word_feats = word_dropout(\n word_feats, self.rng, word_keep_prob\n )\n X[idx].append(word_feats)\n Y.append(\n tuple(\n np.array([convert_label_to_index(w[objective_idx], label2index)\n for w in label], dtype=np.int32)\n for objective_idx, label2index in enumerate(self.label2index)\n )\n )\n\n Y_mask.append(\n tuple(\n build_objective_mask(label, objective_idx, objective_type)\n for objective_idx, objective_type in enumerate(self.objective_types)\n )\n )\n sequence_lengths = np.array([len(x) for x in X[0]], dtype=np.int32)\n X = [pad_arrays_into_array(x, -1) for x in X]\n Y = [\n pad_arrays_into_array([row[objective_idx] for row in Y], 0)\n for objective_idx in range(len(self.objective_types))\n ]\n Y_mask = [\n pad_arrays_into_array([row[objective_idx] for row in Y_mask], 0.0)\n for objective_idx in range(len(self.objective_types))\n ]\n feed_dict = {\n self.sequence_lengths: sequence_lengths\n }\n if self.fused:\n feed_dict[self.labels[0]] = np.stack([y.T for y in Y], axis=-1)\n feed_dict[self.labels_mask[0]] = np.stack([y.T for y in Y_mask], axis=-1)\n else:\n for y, placeholder in zip(Y, self.labels):\n feed_dict[placeholder] = y.T\n for y, placeholder in zip(Y_mask, self.labels_mask):\n feed_dict[placeholder] = y.T\n for idx, x in enumerate(X):\n feed_dict[self.input_placeholders[idx]] = x.swapaxes(0, 1)\n return feed_dict\n\n def as_list(self):\n return list(self.iter_batches())\n\n def iter_batches(self, pbar=None):\n gen = range(len(self.batch_indices))\n if pbar is not None:\n pbar.max_value = len(self.batch_indices)\n pbar.value = 0\n gen = pbar(gen)\n if self.autoresize and self.dataset_is_lazy:\n for idx in gen:\n examples = [self.dataset[ex] for ex in self.batch_indices[idx]]\n ranges = allocate_shrunk_batches(\n max_length=self.max_length,\n batch_size=self.batch_size,\n lengths=[len(ex[0]) for ex in examples]\n )\n for i, j in ranges:\n yield self.generate_batch(examples[i:j])\n else:\n for idx in gen:\n yield self.generate_batch(\n [self.dataset[ex] for ex in self.batch_indices[idx]]\n )\n\n\ndef allocate_shrunk_batches(max_length, batch_size, lengths):\n typical_indices = max_length * batch_size\n i = 0\n ranges = []\n while i < len(lengths):\n j = i + 1\n current_batch_size = 1\n longest_ex = lengths[j - 1]\n while j < len(lengths) and j - i < batch_size:\n # can grow?\n new_batch_size = current_batch_size + 1\n new_j = j + 1\n if max(longest_ex, lengths[new_j - 1]) * new_batch_size < typical_indices:\n j = new_j\n longest_ex = max(longest_ex, lengths[new_j - 1])\n current_batch_size = new_batch_size\n else:\n break\n ranges.append((i, j))\n i = j\n return ranges\n\n\n\ndef batch_worker(rng,\n features,\n feature_word2index,\n objective_types,\n label2index,\n fused,\n sequence_lengths,\n labels,\n labels_mask,\n input_placeholders,\n autoresize,\n train,\n batch_size,\n max_length,\n dataset,\n pbar,\n batch_queue,\n death_event):\n batchifier = Batchifier(\n rng=rng,\n features=features,\n feature_word2index=feature_word2index,\n objective_types=objective_types,\n label2index=label2index,\n fused=fused,\n sequence_lengths=sequence_lengths,\n labels=labels,\n labels_mask=labels_mask,\n input_placeholders=input_placeholders,\n autoresize=autoresize,\n train=train,\n batch_size=batch_size,\n max_length=max_length,\n dataset=dataset\n )\n for batch in batchifier.iter_batches(pbar=pbar):\n if death_event.is_set():\n break\n batch_queue.put(batch)\n if not death_event.is_set():\n batch_queue.put(None)\n\n\ndef range_size(start, size):\n return [i for i in range(start, start + size)]\n\n\nclass ProcessHolder(object):\n def __init__(self, process, death_event, batch_queue):\n self.process = process\n self.batch_queue = batch_queue\n self.death_event = death_event\n\n def close(self):\n self.death_event.set()\n try:\n self.batch_queue.close()\n while True:\n self.batch_queue.get_nowait()\n except Exception as e:\n pass\n self.process.terminate()\n self.process.join()\n\n def __del__(self):\n self.close()\n\n\ndef iter_batches_single_threaded(model,\n dataset,\n batch_size,\n train,\n autoresize=True,\n max_length=100,\n pbar=None):\n tensorflow_placeholders = [model.sequence_lengths] + model.labels + model.labels_mask + model.input_placeholders\n labels_start = 1\n labels_mask_start = labels_start + len(model.labels)\n placeholder_start = labels_mask_start + len(model.labels_mask)\n batchifier = Batchifier(\n rng=model.rng,\n features=model.features,\n feature_word2index=model.feature_word2index,\n objective_types=[obj[\"type\"] for obj in model.objectives],\n label2index=model.label2index,\n fused=model.fused,\n sequence_lengths=0,\n labels=range_size(labels_start, len(model.labels)),\n labels_mask=range_size(labels_mask_start, len(model.labels_mask)),\n input_placeholders=range_size(placeholder_start, len(model.input_placeholders)),\n autoresize=autoresize,\n train=train,\n batch_size=batch_size,\n max_length=max_length,\n dataset=dataset\n )\n for batch in prefetch_generator(batchifier.iter_batches(pbar=pbar), to_fetch=100):\n feed_dict = {}\n for idx, key in enumerate(tensorflow_placeholders):\n feed_dict[key] = batch[idx]\n yield feed_dict\n\n\ndef iter_batches(model,\n dataset,\n batch_size,\n train,\n autoresize=True,\n max_length=100,\n pbar=None):\n import multiprocessing\n batch_queue = multiprocessing.Queue(maxsize=10)\n tensorflow_placeholders = [model.sequence_lengths] + model.labels + model.labels_mask + model.input_placeholders\n labels_start = 1\n labels_mask_start = labels_start + len(model.labels)\n placeholder_start = labels_mask_start + len(model.labels_mask)\n death_event = multiprocessing.Event()\n batch_process = ProcessHolder(multiprocessing.Process(\n target=batch_worker,\n daemon=True,\n args=(\n model.rng,\n model.features,\n model.feature_word2index,\n [obj[\"type\"] for obj in model.objectives],\n model.label2index,\n model.fused,\n 0,\n range_size(labels_start, len(model.labels)),\n range_size(labels_mask_start, len(model.labels_mask)),\n range_size(placeholder_start, len(model.input_placeholders)),\n autoresize,\n train,\n batch_size,\n max_length,\n dataset,\n pbar,\n batch_queue,\n death_event\n )\n ), death_event, batch_queue)\n batch_process.process.name = \"iter_batches\"\n batch_process.process.start()\n while True:\n batch = batch_queue.get()\n if batch is None:\n break\n else:\n feed_dict = {}\n for idx, key in enumerate(tensorflow_placeholders):\n feed_dict[key] = batch[idx]\n yield feed_dict\n del batch\n"}}},{"rowIdx":20,"cells":{"python_code":{"kind":"string","value":"import distutils.ccompiler\nimport distutils.sysconfig\nimport re\nimport numpy as np\nimport sys\nimport subprocess\nfrom setuptools import setup, find_packages\nfrom os.path import join, dirname, realpath, relpath, splitext, exists, getmtime, relpath, lexists, islink\nfrom os import walk, sep, remove, listdir, stat, symlink\n\nfrom Cython.Distutils.extension import Extension\nfrom Cython.Distutils import build_ext\nfrom distutils.core import setup\nfrom distutils.command import build as build_module, clean as clean_module\nfrom distutils.spawn import find_executable\n\nSCRIPT_DIR = dirname(realpath(__file__))\nWIKIDATA_LINKER_SOURCE_DIR = join(SCRIPT_DIR, \"src\")\nWIKIDATA_LINKER_MODULE_NAME = \"wikidata_linker_utils\"\nWIKIDATA_LINKER_INTERNAL_MODULE_NAME = WIKIDATA_LINKER_MODULE_NAME\n\nversion_file = join(SCRIPT_DIR, \"VERSION\")\nif exists(version_file):\n with open(version_file) as f:\n VERSION = f.read().strip()\nelse:\n VERSION = \"1.0.0\"\n\n\ndef path_to_module_name(path):\n BASE_DIRS = [\"python\", \"cython\"]\n relative_path = relpath(path, join(WIKIDATA_LINKER_SOURCE_DIR))\n path_no_ext, _ = splitext(relative_path)\n for base_dir in BASE_DIRS:\n if path_no_ext.startswith(base_dir):\n return path_no_ext.lstrip(base_dir + sep).replace(sep, '.')\n raise Exception(\"Cannot convert path %r to module name\" % (relative_path,))\n\n\ndef find_files_by_suffix(path, suffix):\n \"\"\"Recursively find files with specific suffix in a directory\"\"\"\n for relative_path, dirs, files in walk(path):\n for fname in files:\n if fname.endswith(suffix):\n yield join(path, relative_path, fname)\n\n# Make a `cleanall` rule to get rid of intermediate and library files\nclass clean(clean_module.clean):\n def run(self):\n print(\"Cleaning up cython files...\")\n # Just in case the build directory was created by accident,\n # note that shell=True should be OK here because the command is constant.\n for place in [\"build\",\n join(\"src\", \"cython\", WIKIDATA_LINKER_INTERNAL_MODULE_NAME, \"*.c\"),\n join(\"src\", \"cython\", WIKIDATA_LINKER_INTERNAL_MODULE_NAME, \"*.cpp\"),\n join(\"src\", \"cython\", WIKIDATA_LINKER_INTERNAL_MODULE_NAME, \"*.so\")]:\n subprocess.Popen(\"rm -rf %s\" % (place,),\n shell=True,\n executable=\"/bin/bash\",\n cwd=SCRIPT_DIR)\n\ncompiler = distutils.ccompiler.new_compiler()\ndistutils.sysconfig.customize_compiler(compiler)\nBLACKLISTED_COMPILER_SO = ['-Wp,-D_FORTIFY_SOURCE=2']\nbuild_ext.compiler = compiler\n\next_modules = []\n\nfor pyx_file in find_files_by_suffix(join(WIKIDATA_LINKER_SOURCE_DIR, \"cython\"), \".pyx\"):\n # pxd files are like header files for pyx files\n # and they can also have relevant includes.\n relevant_files = [pyx_file]\n pxd_file = pyx_file[:-3] + \"pxd\"\n if exists(pxd_file):\n relevant_files.append(pxd_file)\n\n ext_modules.append(Extension(\n name=path_to_module_name(pyx_file),\n sources=[pyx_file],\n library_dirs=[],\n language='c++',\n extra_compile_args=['-std=c++11', '-Wno-unused-function',\n '-Wno-sign-compare', '-Wno-unused-local-typedef',\n '-Wno-undefined-bool-conversion', '-O3',\n '-Wno-reorder'],\n extra_link_args=[],\n libraries=[],\n extra_objects=[],\n include_dirs=[np.get_include()]\n ))\n\n################################################################################\n## FIND PYTHON PACKAGES ##\n################################################################################\n\npy_packages = []\nfor file in find_files_by_suffix(join(WIKIDATA_LINKER_SOURCE_DIR, \"python\"), \".py\"):\n module_path = dirname(file)\n py_packages.append(path_to_module_name(module_path))\n\n################################################################################\n## BUILD COMMAND WITH EXTRA WORK WHEN DONE ##\n################################################################################\n\ndef symlink_built_package(module_name, dest_directory):\n build_dir_contents = listdir(join(SCRIPT_DIR, \"build\"))\n lib_dot_fnames = []\n for name in build_dir_contents:\n if name.startswith(\"lib.\"):\n lib_dot_fnames.append(join(SCRIPT_DIR, \"build\", name))\n # get latest lib. file created and symlink it to the project\n # directory for easier testing\n lib_dot_fnames = sorted(\n lib_dot_fnames,\n key=lambda name: stat(name).st_mtime,\n reverse=True\n )\n if len(lib_dot_fnames) == 0:\n return\n\n most_recent_name = join(lib_dot_fnames[0], module_name)\n symlink_name = join(dest_directory, module_name)\n\n if lexists(symlink_name):\n if islink(symlink_name):\n remove(symlink_name)\n else:\n print(\n (\"non symlink file with name %r found in project directory.\"\n \" Please remove to create a symlink on build\") % (\n symlink_name,\n )\n )\n return\n\n symlink(most_recent_name,\n symlink_name,\n target_is_directory=True)\n print(\"Created symlink pointing to %r from %r\" % (\n most_recent_name,\n join(SCRIPT_DIR, module_name)\n ))\n\n\nclass build_with_posthooks(build_module.build):\n def run(self):\n build_module.build.run(self)\n\n\n# Make a `cleanall` rule to get rid of intermediate and library files\nclass clean_with_posthooks(clean_module.clean):\n def run(self):\n clean_module.clean.run(self)\n # remove cython generated sources\n for file_path in find_files_by_suffix(join(WIKIDATA_LINKER_SOURCE_DIR, 'cython'), '.cpp'):\n remove(file_path)\n\nsetup(name=WIKIDATA_LINKER_MODULE_NAME,\n version=VERSION,\n cmdclass={\"build\": build_with_posthooks, 'build_ext': build_ext, 'clean': clean_with_posthooks},\n install_requires=[\"numpy\"],\n extras_require={\"dev\": []},\n author=\"Jonathan Raiman\",\n language='c++',\n author_email=\"raiman@openai.com\",\n ext_modules=ext_modules,\n description=\"Generate data processing utilities for running DeepType.\",\n package_dir={'': join(WIKIDATA_LINKER_SOURCE_DIR, 'python')},\n packages=py_packages)\n"}}},{"rowIdx":21,"cells":{"python_code":{"kind":"string","value":"import re\n\nSTOP_WORDS = {'a', 'an', 'in', 'the', 'of', 'it', 'from', 'with', 'this', 'that', 'they', 'he',\n 'she', 'some', 'where', 'what', 'since', 'his', 'her', 'their', 'le', 'la', 'les', 'il',\n 'elle', 'ce', 'ça', 'ci', 'ceux', 'ceci', 'cela', 'celle', 'se', 'cet', 'cette',\n 'dans', 'avec', 'con', 'sans', 'pendant', 'durant', 'avant', 'après', 'puis', 'el', 'lo', 'la',\n 'ese', 'esto', 'que', 'qui', 'quoi', 'dont', 'ou', 'où', 'si', 'este', 'esta', 'cual',\n 'eso', 'ella', 'depuis', 'y', 'a', 'à', 'su', 'de', \"des\", 'du', 'los', 'las', 'un', 'une', 'una',\n 'uno', 'para', 'asi', 'later', 'into', 'dentro', 'dedans', 'depuis', 'después', 'desde',\n 'al', 'et', 'por', 'at', 'for', 'when', 'why', 'how', 'with', 'whether', 'if',\n 'thus', 'then', 'and', 'but', 'on', 'during', 'while', 'as', 'within', 'was', 'is',\n 'est', 'au', 'fait', 'font', 'va', 'vont', 'sur', 'en', 'pour', 'del', 'cuando',\n 'cuan', 'do', 'does', 'until', 'sinon', 'encore', 'to', 'by', 'be', 'which',\n 'have', 'not', 'were', 'has', 'also', 'its', 'isbn', 'pp.', \"&amp;\", \"p.\", 'ces', 'o'}\n\n\ndef starts_with_apostrophe_letter(word):\n return (\n word.startswith(\"l'\") or\n word.startswith(\"L'\") or\n word.startswith(\"d'\") or\n word.startswith(\"D'\") or\n word.startswith(\"j'\") or\n word.startswith(\"J'\") or\n word.startswith(\"t'\") or\n word.startswith(\"T'\")\n )\n\n\nPUNCTUATION = {\"'\", \",\", \"-\", \"!\", \".\", \"?\", \":\", \"’\"}\n\n\ndef clean_up_trie_source(source, lowercase=True):\n source = source.rstrip().strip('()[]')\n if len(source) > 0 and (source[-1] in PUNCTUATION or source[0] in PUNCTUATION):\n return \"\"\n # remove l'\n if starts_with_apostrophe_letter(source):\n source = source[2:]\n if source.endswith(\"'s\"):\n source = source[:-2]\n tokens = source.split()\n while len(tokens) > 0 and tokens[0].lower() in STOP_WORDS:\n tokens = tokens[1:]\n while len(tokens) > 0 and tokens[-1].lower() in STOP_WORDS:\n tokens = tokens[:-1]\n joined_tokens = \" \".join(tokens)\n if lowercase:\n return joined_tokens.lower()\n return joined_tokens\n\n\nORDINAL_ANCHOR = re.compile(\"^\\d+(st|th|nd|rd|er|eme|ème|ère)$\")\nNUMBER_PUNCTUATION = re.compile(\"^\\d+([\\/\\-,\\.:;%]\\d*)+$\")\n\n\ndef anchor_is_ordinal(anchor):\n return ORDINAL_ANCHOR.match(anchor) is not None\n\n\ndef anchor_is_numbers_slashes(anchor):\n return NUMBER_PUNCTUATION.match(anchor) is not None\n\n\ndef acceptable_anchor(anchor, anchor_trie, blacklist=None):\n return (len(anchor) > 0 and\n not anchor.isdigit() and\n not anchor_is_ordinal(anchor) and\n not anchor_is_numbers_slashes(anchor) and\n anchor in anchor_trie and\n (blacklist is None or anchor not in blacklist))\n"}}},{"rowIdx":22,"cells":{"python_code":{"kind":"string","value":"import sys\nimport importlib.util\nimport traceback\n\nfrom os.path import basename, splitext\n\n\ndef reload_module(path):\n module_name, extension = splitext(basename(path))\n if extension != \".py\":\n raise ValueError(\"path must have a .py extension (got %r)\" % (path,))\n spec = importlib.util.spec_from_file_location(module_name, path)\n module = importlib.util.module_from_spec(spec)\n spec.loader.exec_module(module)\n return module\n\n\ndef enter_or_quit():\n wait = input(\"press any key to continue, q to quit.\")\n received = wait.rstrip()\n if received == 'q':\n print(\"Bye.\")\n sys.exit(0)\n else:\n return received\n\n\nALLOWED_RUNTIME_ERRORS = (\n TypeError,\n ValueError,\n IndexError,\n NameError,\n KeyError,\n AssertionError,\n AttributeError,\n ImportError,\n KeyboardInterrupt\n)\n\nALLOWED_IMPORT_ERRORS = (\n SyntaxError,\n NameError,\n ImportError\n)\n\n\ndef reload_run_retry(module_path, callback):\n while True:\n try:\n module = reload_module(module_path)\n except ALLOWED_IMPORT_ERRORS as e:\n print(\"issue reading %r, please fix.\" % (module_path,))\n print(str(e))\n traceback.print_exc(file=sys.stdout)\n enter_or_quit()\n continue\n try:\n result = callback(module)\n except ALLOWED_RUNTIME_ERRORS as e:\n print(\"issue running %r, please fix.\" % (module_path,))\n print(str(e))\n traceback.print_exc(file=sys.stdout)\n enter_or_quit()\n continue\n break\n return result\n"}}},{"rowIdx":23,"cells":{"python_code":{"kind":"string","value":"import subprocess\n\n\ndef execute_bash(command):\n \"\"\"\n Executes bash command, prints output and\n throws an exception on failure.\n \"\"\"\n process = subprocess.Popen(command,\n shell=True,\n stdout=subprocess.PIPE,\n stderr=subprocess.STDOUT,\n universal_newlines=True)\n for line in process.stdout:\n print(line, end='', flush=True)\n process.wait()\n assert process.returncode == 0\n\n\ndef get_bash_result(command):\n \"\"\"\n Executes bash command, returns output and throws\n an exception on failure.\n \"\"\"\n process = subprocess.Popen(command,\n shell=True,\n stdout=subprocess.PIPE,\n stderr=subprocess.STDOUT,\n universal_newlines=True)\n out = [line for line in process.stdout]\n process.wait()\n assert process.returncode == 0\n return out\n\n\ndef count_lines(path):\n return int(\n get_bash_result('wc -l %s' % (path,))[0].strip().split(' ')[0]\n )\n"}}},{"rowIdx":24,"cells":{"python_code":{"kind":"string","value":""}}},{"rowIdx":25,"cells":{"python_code":{"kind":"string","value":"import json\nimport msgpack\nimport bz2\n\n\ndef iterate_bytes_jsons(fin, batch_size=1000):\n current = []\n for l in fin:\n if l.startswith(b'{'):\n current.append(l)\n if len(current) >= batch_size:\n docs = json.loads('[' + b\"\".join(current).decode('utf-8').rstrip(',\\n') + ']')\n for doc in docs:\n yield doc\n current = []\n if len(current) > 0:\n docs = json.loads('[' + b\"\".join(current).decode('utf-8').rstrip(',\\n') + ']')\n for doc in docs:\n yield doc\n current = []\n\n\ndef iterate_text_jsons(fin, batch_size=1000):\n current = []\n for l in fin:\n if l.startswith('{'):\n current.append(l)\n if len(current) >= batch_size:\n docs = json.loads('[' + \"\".join(current).rstrip(',\\n') + ']')\n for doc in docs:\n yield doc\n current = []\n if len(current) > 0:\n docs = json.loads('[' + \"\".join(current).rstrip(',\\n') + ']')\n for doc in docs:\n yield doc\n current = []\n\n\ndef iterate_message_packs(fin):\n\n unpacker = msgpack.Unpacker(fin, encoding='utf-8', use_list=False)\n for obj in unpacker:\n yield obj\n\n\ndef open_wikidata_file(path, batch_size):\n if path.endswith('bz2'):\n with bz2.open(path, 'rb') as fin:\n for obj in iterate_bytes_jsons(fin, batch_size):\n yield obj\n elif path.endswith('json'):\n with open(path, 'rt') as fin:\n for obj in iterate_text_jsons(fin, batch_size):\n yield obj\n elif path.endswith('mp'):\n with open(path, 'rb') as fin:\n for obj in iterate_message_packs(fin):\n yield obj\n else:\n raise ValueError(\n \"unknown extension for wikidata. \"\n \"Expecting bz2, json, or mp (msgpack).\"\n )\n"}}},{"rowIdx":26,"cells":{"python_code":{"kind":"string","value":"from numpy import logical_and, logical_not, logical_or\n\n\ndef logical_negate(truth, falses):\n out = truth\n for value in falses:\n out = logical_and(out, logical_not(value))\n return out\n\n\ndef logical_ors(values):\n assert(len(values) > 0), \"values cannot be empty.\"\n out = values[0]\n for val in values[1:]:\n out = logical_or(out, val)\n return out\n\n\ndef logical_ands(values):\n assert(len(values) > 0), \"values cannot be empty.\"\n out = values[0]\n for val in values[1:]:\n out = logical_and(out, val)\n return out\n"}}},{"rowIdx":27,"cells":{"python_code":{"kind":"string","value":"import json\nimport warnings\n\nfrom os.path import join, exists\nfrom functools import lru_cache\n\nimport marisa_trie\nimport requests\nimport numpy as np\n\nfrom .successor_mask import (\n successor_mask, invert_relation, offset_values_mask\n)\nfrom .offset_array import OffsetArray, SparseAttribute\nfrom .wikidata_ids import (\n load_wikidata_ids, load_names, property_names, temporal_property_names\n)\nfrom . import wikidata_properties as wprop\n\n\nclass CachedRelation(object):\n def __init__(self, use, state):\n self.use = use\n self.state = state\n\n\n@lru_cache(maxsize=None)\ndef get_name(wikidata_id):\n res = requests.get(\"https://www.wikidata.org/wiki/\" + wikidata_id)\n el = res.text.find('')\n return res.text[el + len('