{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Using TensorFlow backend.\n" ] } ], "source": [ "import keras\n", "from keras.models import Sequential, Model, load_model\n", "\n", "from keras.layers import Dense, Dropout, Activation, Flatten, Input, Lambda\n", "from keras.layers import Conv2D, MaxPooling2D, Conv1D, MaxPooling1D, LSTM, ConvLSTM2D, GRU, BatchNormalization, LocallyConnected2D, Permute\n", "from keras.layers import Concatenate, Reshape, Softmax, Conv2DTranspose, Embedding, Multiply\n", "from keras.callbacks import ModelCheckpoint, EarlyStopping, Callback\n", "from keras import regularizers\n", "from keras import backend as K\n", "import keras.losses\n", "\n", "import tensorflow as tf\n", "from tensorflow.python.framework import ops\n", "\n", "import isolearn.keras as iso\n", "\n", "import numpy as np\n", "\n", "import tensorflow as tf\n", "import logging\n", "logging.getLogger('tensorflow').setLevel(logging.ERROR)\n", "\n", "import pandas as pd\n", "\n", "import os\n", "import pickle\n", "import numpy as np\n", "\n", "import scipy.sparse as sp\n", "import scipy.io as spio\n", "\n", "import matplotlib.pyplot as plt\n", "\n", "import isolearn.io as isoio\n", "import isolearn.keras as isol\n", "\n", "from genesis.visualization import *\n", "from genesis.generator import *\n", "from genesis.predictor import *\n", "from genesis.optimizer import *\n", "import sklearn\n", "from sklearn.decomposition import PCA\n", "from sklearn.manifold import TSNE\n", "\n", "from scipy.stats import pearsonr\n", "\n", "import seaborn as sns\n", "\n", "from matplotlib import colors\n", "\n", "import editdistance\n", "\n", "def subselect_list(li, ixs) :\n", " return [\n", " li[ixs[k]] for k in range(len(ixs))\n", " ]\n", "\n", "class IdentityEncoder(iso.SequenceEncoder) :\n", " \n", " def __init__(self, seq_len, channel_map) :\n", " super(IdentityEncoder, self).__init__('identity', (seq_len, len(channel_map)))\n", " \n", " self.seq_len = seq_len\n", " self.n_channels = len(channel_map)\n", " self.encode_map = channel_map\n", " self.decode_map = {\n", " nt: ix for ix, nt in self.encode_map.items()\n", " }\n", " \n", " def encode(self, seq) :\n", " encoding = np.zeros((self.seq_len, self.n_channels))\n", " \n", " for i in range(len(seq)) :\n", " if seq[i] in self.encode_map :\n", " channel_ix = self.encode_map[seq[i]]\n", " encoding[i, channel_ix] = 1.\n", "\n", " return encoding\n", " \n", " def encode_inplace(self, seq, encoding) :\n", " for i in range(len(seq)) :\n", " if seq[i] in self.encode_map :\n", " channel_ix = self.encode_map[seq[i]]\n", " encoding[i, channel_ix] = 1.\n", " \n", " def encode_inplace_sparse(self, seq, encoding_mat, row_index) :\n", " raise NotImplementError()\n", " \n", " def decode(self, encoding) :\n", " seq = ''\n", " \n", " for pos in range(0, encoding.shape[0]) :\n", " argmax_nt = np.argmax(encoding[pos, :])\n", " max_nt = np.max(encoding[pos, :])\n", " seq += self.decode_map[argmax_nt]\n", "\n", " return seq\n", " \n", " def decode_sparse(self, encoding_mat, row_index) :\n", " raise NotImplementError()\n", "\n", "#Plot joint histograms\n", "def plot_joint_histo(measurements, labels, x_label, y_label, colors=None, n_bins=50, figsize=(6, 4), legend_outside=False, save_fig=False, fig_name=\"default_1\", fig_dpi=150, min_val=None, max_val=None, max_y_val=None) :\n", " \n", " min_hist_val = np.min(measurements[0])\n", " max_hist_val = np.max(measurements[0])\n", " for i in range(1, len(measurements)) :\n", " min_hist_val = min(min_hist_val, np.min(measurements[i]))\n", " max_hist_val = max(max_hist_val, np.max(measurements[i]))\n", " \n", " if min_val is not None :\n", " min_hist_val = min_val\n", " if max_val is not None :\n", " max_hist_val = max_val\n", "\n", " hists = []\n", " bin_edges = []\n", " means = []\n", " for i in range(len(measurements)) :\n", " hist, b_edges = np.histogram(measurements[i], range=(min_hist_val, max_hist_val), bins=n_bins, density=True)\n", " \n", " hists.append(hist)\n", " bin_edges.append(b_edges)\n", " means.append(np.mean(measurements[i]))\n", " \n", " bin_width = bin_edges[0][1] - bin_edges[0][0]\n", "\n", "\n", " f = plt.figure(figsize=figsize)\n", "\n", " for i in range(len(measurements)) :\n", " if colors is not None :\n", " plt.bar(bin_edges[i][1:] - bin_width/2., hists[i], width=bin_width, linewidth=2, edgecolor='black', color=colors[i], label=labels[i])\n", " else :\n", " plt.bar(bin_edges[i][1:] - bin_width/2., hists[i], width=bin_width, linewidth=2, edgecolor='black', label=labels[i])\n", " \n", " plt.xticks(fontsize=14)\n", " plt.yticks(fontsize=14)\n", " \n", " plt.xlim(min_hist_val, max_hist_val)\n", " if max_y_val is not None :\n", " plt.ylim(0, max_y_val)\n", "\n", " plt.xlabel(x_label, fontsize=14)\n", " plt.ylabel(y_label, fontsize=14)\n", "\n", " if colors is not None :\n", " for i in range(len(measurements)) :\n", " plt.axvline(x=means[i], linewidth=2, color=colors[i], linestyle=\"--\")\n", "\n", " if not legend_outside :\n", " plt.legend(fontsize=14, loc='upper left')\n", " else :\n", " plt.legend(fontsize=14, bbox_to_anchor=(1.04,1), loc=\"upper left\")\n", " \n", " plt.tight_layout()\n", " \n", " if save_fig :\n", " plt.savefig(fig_name + \".eps\")\n", " plt.savefig(fig_name + \".svg\")\n", " plt.savefig(fig_name + \".png\", dpi=fig_dpi, transparent=True)\n", " \n", " plt.show()\n", "\n", "#Plot join histograms\n", "def plot_joint_cmp(measurements, labels, y_label, plot_type='violin', colors=None, figsize=(6, 4), legend_outside=False, save_fig=False, fig_name=\"default_1\", fig_dpi=150, min_y_val=None, max_y_val=None, violin_bw=None, violin_cut=None) :\n", " \n", " f = plt.figure(figsize=figsize)\n", "\n", " sns_g = None\n", " if colors is not None :\n", " if plot_type == 'violin' :\n", " if violin_bw is None :\n", " if violin_cut is None :\n", " sns_g = sns.violinplot(data=measurements, palette=colors, scale='width')\n", " else :\n", " sns_g = sns.violinplot(data=measurements, palette=colors, scale='width', cut=violin_cut)\n", " else :\n", " if violin_cut is None :\n", " sns_g = sns.violinplot(data=measurements, palette=colors, scale='width', bw=violin_bw)\n", " else :\n", " sns_g = sns.violinplot(data=measurements, palette=colors, scale='width', bw=violin_bw, cut=violin_cut)\n", " elif plot_type == 'strip' :\n", " sns_g = sns.stripplot(data=measurements, palette=colors, alpha=0.1, jitter=0.3, linewidth=2, edgecolor='black') #, x=labels\n", " for i in range(len(measurements)) :\n", " plt.plot(x=[i, i+1], y=[np.median(measurements[i]), np.median(measurements[i])], linewidth=2, color=colors[i], linestyle=\"--\")\n", " elif plot_type == 'bar' :\n", " for i in range(len(measurements)) :\n", " plt.bar([i], [np.percentile(measurements[i], 100)], width=0.4, color=colors[i], label=str(i) + \") \" + labels[i], linewidth=2, edgecolor='black')\n", " plt.bar([i+0.2], [np.percentile(measurements[i], 95)], width=0.4, color=colors[i], linewidth=2, edgecolor='black')\n", " plt.bar([i+0.4], [np.percentile(measurements[i], 80)], width=0.4, color=colors[i], linewidth=2, edgecolor='black')\n", " plt.bar([i+0.6], [np.percentile(measurements[i], 50)], width=0.4, color=colors[i], linewidth=2, edgecolor='black')\n", " else :\n", " if plot_type == 'violin' :\n", " if violin_bw is None :\n", " if violin_cut is None :\n", " sns_g = sns.violinplot(data=measurements, scale='width')\n", " else :\n", " sns_g = sns.violinplot(data=measurements, scale='width', cut=violin_cut)\n", " else :\n", " if violin_cut is None :\n", " sns_g = sns.violinplot(data=measurements, scale='width', bw=violin_bw)\n", " else :\n", " sns_g = sns.violinplot(data=measurements, scale='width', bw=violin_bw, cut=violin_cut)\n", " elif plot_type == 'strip' :\n", " sns_g = sns.stripplot(data=measurements, alpha=0.1, jitter=0.3, linewidth=2, edgecolor='black') #, x=labels\n", " elif plot_type == 'bar' :\n", " for i in range(len(measurements)) :\n", " plt.bar([i], [np.percentile(measurements[i], 100)], width=0.25, label=str(i) + \") \" + labels[i], linewidth=2, edgecolor='black')\n", " plt.bar([i+0.125], [np.percentile(measurements[i], 95)], width=0.25, linewidth=2, edgecolor='black')\n", " plt.bar([i+0.25], [np.percentile(measurements[i], 80)], width=0.25, linewidth=2, edgecolor='black')\n", " plt.bar([i+0.375], [np.percentile(measurements[i], 50)], width=0.25, linewidth=2, edgecolor='black')\n", " \n", " plt.xticks(np.arange(len(labels)), fontsize=14)\n", " plt.yticks(fontsize=14)\n", " \n", " #plt.xlim(min_hist_val, max_hist_val)\n", " if min_y_val is not None and max_y_val is not None :\n", " plt.ylim(min_y_val, max_y_val)\n", "\n", " plt.ylabel(y_label, fontsize=14)\n", " \n", " if plot_type not in ['violin', 'strip'] :\n", " if not legend_outside :\n", " plt.legend(fontsize=14, loc='upper left')\n", " else :\n", " plt.legend(fontsize=14, bbox_to_anchor=(1.04,1), loc=\"upper left\")\n", " else :\n", " if not legend_outside :\n", " f.get_axes()[0].legend(fontsize=14, loc=\"upper left\", labels=[str(label_i) + \") \" + label for label_i, label in enumerate(labels)])\n", " else :\n", " f.get_axes()[0].legend(fontsize=14, bbox_to_anchor=(1.04,1), loc=\"upper left\", labels=[str(label_i) + \") \" + label for label_i, label in enumerate(labels)])\n", " \n", " plt.tight_layout()\n", " \n", " if save_fig :\n", " plt.savefig(fig_name + \".eps\")\n", " plt.savefig(fig_name + \".svg\")\n", " plt.savefig(fig_name + \".png\", dpi=fig_dpi, transparent=True)\n", " \n", " plt.show()\n", "\n", "#Load generated data from models to be evaluated\n", "\n", "def load_sequences(file_path, split_on_tab=True, seq_template=None, max_n_sequences=1e6, select_best_fitness=False, predictor=None, batch_size=32) :\n", " seqs = []\n", " \n", " with open(file_path, \"rt\") as f :\n", " for l in f.readlines() :\n", " l_strip = l.strip()\n", " seq = l_strip\n", " if split_on_tab :\n", " seq = l_strip.split(\"\\t\")[0]\n", " \n", " if seq_template is not None :\n", " seq = ''.join([\n", " seq_template[j] if seq_template[j] != 'N' else seq[j]\n", " for j in range(len(seq))\n", " ])\n", "\n", " seqs.append(seq)\n", " \n", " if select_best_fitness and predictor is not None :\n", " onehots = np.expand_dims(np.concatenate([\n", " np.expand_dims(acgt_encoder.encode(seq), axis=0) for seq in seqs\n", " ], axis=0), axis=1)\n", "\n", " #Predict fitness\n", " score_pred = predictor.predict(x=[onehots], batch_size=batch_size)\n", " score_pred = np.ravel(score_pred[:, 0])\n", " \n", " sort_index = np.argsort(score_pred)[::-1]\n", " seqs = [\n", " seqs[sort_index[i]] for i in range(len(seqs))\n", " ]\n", " \n", " return seqs[:max_n_sequences]\n", "\n", "#Metric helper functions\n", "\n", "def compute_edit_distance(onehots, opt_len=100) :\n", " shuffle_index = np.arange(onehots.shape[0])\n", " shuffle_index = shuffle_index[::-1]#np.random.shuffle(shuffle_index)\n", " \n", " seqs = [acgt_encoder.decode(onehots[i, :, :, 0]) for i in range(onehots.shape[0])]\n", " seqs_shuffled = [seqs[shuffle_index[i]] for i in range(onehots.shape[0])]\n", " edit_distances = np.ravel([float(editdistance.eval(seq_1, seq_2)) for seq_1, seq_2 in zip(seqs, seqs_shuffled)])\n", " edit_distances /= opt_len\n", " \n", " mean_edit_distance = np.mean(edit_distances)\n", " \n", " return edit_distances, mean_edit_distance\n", "\n", "#Evaluate metrics for each model\n", "\n", "def compute_metrics(seqs, n_seqs_to_test=960, batch_size=64, opt_len=90) :\n", " \n", " n_seqs_to_test = min(len(seqs), n_seqs_to_test)\n", " \n", " onehots = np.expand_dims(np.concatenate([\n", " np.expand_dims(acgt_encoder.encode(seq), axis=0) for seq in seqs\n", " ], axis=0), axis=-1)\n", "\n", " #Predict fitness\n", " score_pred = saved_predictor.predict(x=[np.moveaxis(onehots[:n_seqs_to_test], 3, 1)], batch_size=batch_size)\n", " score_pred = np.ravel(score_pred[:, 0])\n", " \n", " #Compare pair-wise edit distances\n", " edit_dists, _ = compute_edit_distance(onehots[:n_seqs_to_test], opt_len=opt_len)\n", " \n", " return score_pred, edit_dists\n", "\n", "from keras.backend.tensorflow_backend import set_session\n", "\n", "def contain_tf_gpu_mem_usage() :\n", " config = tf.ConfigProto()\n", " config.gpu_options.allow_growth = True\n", " sess = tf.Session(config=config)\n", " set_session(sess)\n", "\n", "contain_tf_gpu_mem_usage()\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "\n", "sequence_template = 'N' * 1000\n", "\n", "problem_prefix = \"dragonn_genesis_max_spi1\"\n", "\n", "n_seqs_to_test = 4000\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "scrolled": true }, "outputs": [], "source": [ "#Specfiy file path to pre-trained predictor network\n", "\n", "saved_predictor_model_path = \"../../../seqprop/examples/dragonn/SPI1.classification.model.hdf5\"\n", "\n", "def _dummy_min_pred(y_true, y_pred) :\n", " return y_pred\n", "\n", "saved_predictor = load_model(saved_predictor_model_path, custom_objects={\n", " 'ambig_binary_crossentropy' : _dummy_min_pred,\n", " 'precision' : _dummy_min_pred,\n", " 'recall' : _dummy_min_pred,\n", " 'specificity' : _dummy_min_pred,\n", " 'fpr' : _dummy_min_pred,\n", " 'fnr' : _dummy_min_pred,\n", " 'fdr' : _dummy_min_pred,\n", " 'f1' : _dummy_min_pred\n", "})\n", "\n", "saved_predictor = Model(\n", " inputs=saved_predictor.inputs,\n", " outputs = [saved_predictor.get_layer('dense_2').output]\n", ")\n", "\n", "saved_predictor.compile(\n", " loss='mse',\n", " optimizer=keras.optimizers.SGD(lr=0.1)\n", ")\n", "\n", "\n", "acgt_encoder = IdentityEncoder(1000, {'A':0, 'C':1, 'G':2, 'T':3})\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "\n", "#Build random data\n", "random_sequences = [\n", " ''.join([\n", " sequence_template[j] if sequence_template[j] != 'N' else np.random.choice(['A', 'C', 'G', 'T'])\n", " for j in range(len(sequence_template))\n", " ]) for i in range(n_seqs_to_test)\n", "]\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "#Load generated data from models to be evaluated\n", "\n", "model_sequence_files = [\n", " \"basinhopping_dragonn_max_spi1_1000_iters_dense_score_512_sequences.txt\",\n", " \"basinhopping_dragonn_max_spi1_10000_iters_dense_score_512_sequences.txt\",\n", " \n", " \"genesis_dragonn_max_spi1_25000_updates_similarity_margin_02_earthmover_weight_01_target_700_fixed_trainmode_4096_sequences.txt\",\n", " \"genesis_dragonn_max_spi1_25000_updates_similarity_seq_margin_02_lat_margin_09_earthmover_weight_01_target_700_trainmode_4096_sequences.txt\",\n", " \"genesis_dragonn_max_spi1_25000_updates_similarity_seq_margin_02_lat_margin_07_earthmover_weight_01_target_700_trainmode_4096_sequences.txt\",\n", " \"genesis_dragonn_max_spi1_25000_updates_similarity_margin_02_earthmover_weight_01_target_800_fixed_trainmode_4096_sequences.txt\",\n", " \"genesis_dragonn_max_spi1_25000_updates_similarity_seq_margin_02_lat_margin_09_earthmover_weight_01_target_800_trainmode_4096_sequences.txt\",\n", " \"genesis_dragonn_max_spi1_25000_updates_similarity_seq_margin_02_lat_margin_07_earthmover_weight_01_target_800_trainmode_4096_sequences.txt\"\n", "]\n", "\n", "model_names = [\n", " \"Simulated Annealing (1000 iters)\",\n", " \"Simulated Annealing (10000 iters)\",\n", " \n", " \"DEN Earthm 70 (seq margin 0.2)\",\n", " \"DEN Earthm 70 (seq/lat margin 0.2/0.9)\",\n", " \"DEN Earthm 70 (seq/lat margin 0.2/0.7)\",\n", " \"DEN Earthm 80 (seq margin 0.2)\",\n", " \"DEN Earthm 80 (seq/lat margin 0.2/0.9)\",\n", " \"DEN Earthm 80 (seq/lat margin 0.2/0.7)\"\n", "]\n", "\n", "model_sequences = [\n", " load_sequences(model_sequence_file,\n", " split_on_tab=True,\n", " seq_template=sequence_template,\n", " max_n_sequences=n_seqs_to_test,\n", " select_best_fitness=True,\n", " predictor=saved_predictor\n", " )\n", " for model_sequence_file in model_sequence_files\n", "]\n", "\n", "model_names = [\n", " \"Random\"\n", "] + model_names\n", "\n", "model_sequences = [\n", " random_sequences\n", "] + model_sequences\n", "\n", "model_opt_lens = [\n", " 1000\n", "] * len(model_sequences)\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "#Compute all metrics for all models\n", "\n", "model_metrics = [\n", " compute_metrics(seqs, n_seqs_to_test=n_seqs_to_test, batch_size=64, opt_len=opt_l)\n", " for seqs, opt_l in zip(model_sequences, model_opt_lens)\n", "]\n", "\n", "fitness_scores, edit_distances = zip(*model_metrics)\n", "\n", "fitness_scores = list(fitness_scores)\n", "edit_distances = list(edit_distances)\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "scrolled": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/scipy/stats/stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n", " return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#All models, analysis and comparisons\n", "\n", "experiment_suffix = \"_all_comparisons\"\n", "\n", "model_ixs = [1, 2, 3, 4, 5, 6, 7, 8]\n", "\n", "model_colors = ['orchid', 'indigo', 'orange', 'darkorange', 'darkgoldenrod', 'orange', 'darkorange', 'darkgoldenrod']\n", "\n", "violin_bw = 0.5\n", "violin_cut = 0.0\n", "\n", "plot_joint_histo(\n", " subselect_list(fitness_scores, model_ixs),\n", " subselect_list(model_names, model_ixs),\n", " 'Fitness score',\n", " 'Data density',\n", " colors=model_colors,\n", " n_bins=50,\n", " figsize=(12, 4),\n", " save_fig=True,\n", " fig_name=problem_prefix + experiment_suffix + \"_fitness_log_histo\",\n", " legend_outside=True\n", ")\n", "plot_joint_histo(\n", " subselect_list(edit_distances, model_ixs),\n", " subselect_list(model_names, model_ixs),\n", " 'Edit distance / nt',\n", " 'Data density',\n", " colors=model_colors,\n", " min_val=0.25,\n", " max_val=0.75,\n", " n_bins=50,\n", " figsize=(12, 4),\n", " save_fig=True,\n", " fig_name=problem_prefix + experiment_suffix + \"_edit_distance_histo\",\n", " legend_outside=True\n", ")\n", "\n", "model_ixs = [1, 2, 3, 4, 5, 6, 7, 8]\n", "\n", "model_colors = ['orchid', 'indigo', 'orange', 'darkorange', 'darkgoldenrod', 'orange', 'darkorange', 'darkgoldenrod']\n", "\n", "plot_joint_cmp(\n", " subselect_list(fitness_scores, model_ixs),\n", " subselect_list(model_names, model_ixs),\n", " 'Fitness score',\n", " plot_type='violin',\n", " colors=model_colors,\n", " figsize=(12, 4),\n", " save_fig=True,\n", " fig_name=problem_prefix + experiment_suffix + \"_fitness_log_violin\",\n", " legend_outside=True,\n", " violin_bw=violin_bw,\n", " violin_cut=violin_cut\n", ")\n", "plot_joint_cmp(\n", " subselect_list(edit_distances, model_ixs),\n", " subselect_list(model_names, model_ixs),\n", " 'Edit distance / nt',\n", " plot_type='violin',\n", " colors=model_colors,\n", " figsize=(12, 4),\n", " save_fig=True,\n", " fig_name=problem_prefix + experiment_suffix + \"_edit_distance_violin\",\n", " legend_outside=True,\n", " violin_bw=violin_bw,\n", " violin_cut=violin_cut\n", ")\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Environment (conda_tensorflow_p36)", "language": "python", "name": "conda_tensorflow_p36" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.5" } }, "nbformat": 4, "nbformat_minor": 2 }