diff --git a/metapath2vec.ipynb b/metapath2vec.ipynb new file mode 100644 index 0000000..c78c6e1 --- /dev/null +++ b/metapath2vec.ipynb @@ -0,0 +1,257 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "# %conda activate py38\n", + "%pip install stellargraph chardet -Uq" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "%reload_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import stellargraph as sg\n", + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "StellarGraph: Undirected multigraph\n", + " Nodes: 6, Edges: 5\n", + "\n", + " Node types:\n", + " task: [3]\n", + " Features: float32 vector, length 1\n", + " Edge types: task-default->construct, task-default->task\n", + " construct: [3]\n", + " Features: float32 vector, length 1\n", + " Edge types: construct-default->construct, construct-default->task\n", + "\n", + " Edge types:\n", + " task-default->task: [2]\n", + " Weights: range=[1, 2], mean=1.5, std=0.707107\n", + " Features: none\n", + " construct-default->construct: [2]\n", + " Weights: range=[10, 12], mean=11, std=1.41421\n", + " Features: none\n", + " construct-default->task: [1]\n", + " Weights: all 10\n", + " Features: none\n" + ] + } + ], + "source": [ + "tasks = pd.DataFrame(\n", + " [10,20,30],\n", + " index = ['t1','t2','t3']\n", + ")\n", + "\n", + "constructs = pd.DataFrame(\n", + " [50,60,70],\n", + " index = ['c1','c2','c3']\n", + ")\n", + "\n", + "edges = pd.DataFrame(\n", + " {'source': ['t1', 't2', 'c1', 'c2', 't1'],\n", + " 'target': ['t2', 't3', 'c2', 'c1', 'c1'],\n", + " 'weight': [1, 2, 10, 12, 10]},\n", + ")\n", + "\n", + "G = sg.StellarGraph({'task': tasks, 'construct': constructs}, edges=edges)\n", + "print(G.info())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of random walks: {len(walks)}\n" + ] + }, + { + "data": { + "text/plain": [ + "[['c1', 'c2', 'c1', 'c2', 'c1'],\n", + " ['c2', 'c1', 'c2', 'c1', 'c2'],\n", + " ['c3'],\n", + " ['t1', 'c1', 't1', 'c1', 't1'],\n", + " ['t1', 'c1', 'c2'],\n", + " ['t2'],\n", + " ['t2'],\n", + " ['t3'],\n", + " ['t3']]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# metapath2vec\n", + "\n", + "rnd_walk_length = 5 # maximum length of a random walk\n", + "\n", + "# metapath schemas as a list of lists of node types.\n", + "metapaths = [\n", + " ['task', 'construct', 'task'],\n", + " ['construct', 'construct'],\n", + " ['task', 'construct', 'construct', 'task'],\n", + "]\n", + "\n", + "\n", + "from stellargraph.data import UniformRandomMetaPathWalk\n", + "\n", + "rw = UniformRandomMetaPathWalk(G)\n", + "\n", + "walks = rw.run(\n", + " nodes=list(G.nodes()), # root nodes\n", + " length=rnd_walk_length, # maximum length of a random walk\n", + " n=1, # number of random walks per root node\n", + " metapaths=metapaths, # the metapaths\n", + ")\n", + "\n", + "print('Number of random walks: {len(walks)}')\n", + "walks" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "shape: (6, 128)\n" + ] + }, + { + "data": { + "text/plain": [ + "[('c1', 0.0630912259221077),\n", + " ('t2', 0.02670864760875702),\n", + " ('t3', -0.016970207914710045),\n", + " ('c2', -0.07985257357358932),\n", + " ('c3', -0.15879441797733307)]" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from gensim.models import Word2Vec\n", + "\n", + "model = Word2Vec(walks, vector_size=128, window=5, min_count=0, sg=1, workers=2, epochs=1)\n", + "print('shape:', model.wv.vectors.shape)\n", + "model.wv.most_similar('t1')" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/Caskroom/miniforge/base/envs/py38/lib/python3.8/site-packages/sklearn/manifold/_t_sne.py:780: FutureWarning: The default initialization in TSNE will change from 'random' to 'pca' in 1.2.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# viz\n", + "\n", + "node_embeddings = model.wv.vectors\n", + "node_types = [G.node_type(node_id) for node_id in model.wv.index_to_key]\n", + "\n", + "from sklearn.manifold import TSNE\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "node_embeddings_2d = TSNE(n_components=2, learning_rate='auto').fit_transform(node_embeddings)\n", + "node_embeddings_2d\n", + "\n", + "label_map = {l: i for i, l in enumerate(np.unique(node_types))}\n", + "node_colors = [label_map[t] for t in node_types]\n", + "\n", + "plt.figure(figsize=(20, 16))\n", + "plt.axes().set(aspect=\"equal\")\n", + "plt.scatter(node_embeddings_2d[:, 0], node_embeddings_2d[:, 1], c=node_colors, alpha=0.3)\n", + "plt.title('2d projection of the node embeddings')\n", + "plt.show()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "4bc0b60e31b0a7441a2e25ec194980ab62b84e91a65eae3f6b114824d9f7dec0" + }, + "kernelspec": { + "display_name": "Python 3.8.12 64-bit ('py38': conda)", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/metapath2vec.ipynb b/metapath2vec.ipynb new file mode 100644 index 0000000..c78c6e1 --- /dev/null +++ b/metapath2vec.ipynb @@ -0,0 +1,257 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "# %conda activate py38\n", + "%pip install stellargraph chardet -Uq" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "%reload_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import stellargraph as sg\n", + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "StellarGraph: Undirected multigraph\n", + " Nodes: 6, Edges: 5\n", + "\n", + " Node types:\n", + " task: [3]\n", + " Features: float32 vector, length 1\n", + " Edge types: task-default->construct, task-default->task\n", + " construct: [3]\n", + " Features: float32 vector, length 1\n", + " Edge types: construct-default->construct, construct-default->task\n", + "\n", + " Edge types:\n", + " task-default->task: [2]\n", + " Weights: range=[1, 2], mean=1.5, std=0.707107\n", + " Features: none\n", + " construct-default->construct: [2]\n", + " Weights: range=[10, 12], mean=11, std=1.41421\n", + " Features: none\n", + " construct-default->task: [1]\n", + " Weights: all 10\n", + " Features: none\n" + ] + } + ], + "source": [ + "tasks = pd.DataFrame(\n", + " [10,20,30],\n", + " index = ['t1','t2','t3']\n", + ")\n", + "\n", + "constructs = pd.DataFrame(\n", + " [50,60,70],\n", + " index = ['c1','c2','c3']\n", + ")\n", + "\n", + "edges = pd.DataFrame(\n", + " {'source': ['t1', 't2', 'c1', 'c2', 't1'],\n", + " 'target': ['t2', 't3', 'c2', 'c1', 'c1'],\n", + " 'weight': [1, 2, 10, 12, 10]},\n", + ")\n", + "\n", + "G = sg.StellarGraph({'task': tasks, 'construct': constructs}, edges=edges)\n", + "print(G.info())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of random walks: {len(walks)}\n" + ] + }, + { + "data": { + "text/plain": [ + "[['c1', 'c2', 'c1', 'c2', 'c1'],\n", + " ['c2', 'c1', 'c2', 'c1', 'c2'],\n", + " ['c3'],\n", + " ['t1', 'c1', 't1', 'c1', 't1'],\n", + " ['t1', 'c1', 'c2'],\n", + " ['t2'],\n", + " ['t2'],\n", + " ['t3'],\n", + " ['t3']]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# metapath2vec\n", + "\n", + "rnd_walk_length = 5 # maximum length of a random walk\n", + "\n", + "# metapath schemas as a list of lists of node types.\n", + "metapaths = [\n", + " ['task', 'construct', 'task'],\n", + " ['construct', 'construct'],\n", + " ['task', 'construct', 'construct', 'task'],\n", + "]\n", + "\n", + "\n", + "from stellargraph.data import UniformRandomMetaPathWalk\n", + "\n", + "rw = UniformRandomMetaPathWalk(G)\n", + "\n", + "walks = rw.run(\n", + " nodes=list(G.nodes()), # root nodes\n", + " length=rnd_walk_length, # maximum length of a random walk\n", + " n=1, # number of random walks per root node\n", + " metapaths=metapaths, # the metapaths\n", + ")\n", + "\n", + "print('Number of random walks: {len(walks)}')\n", + "walks" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "shape: (6, 128)\n" + ] + }, + { + "data": { + "text/plain": [ + "[('c1', 0.0630912259221077),\n", + " ('t2', 0.02670864760875702),\n", + " ('t3', -0.016970207914710045),\n", + " ('c2', -0.07985257357358932),\n", + " ('c3', -0.15879441797733307)]" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from gensim.models import Word2Vec\n", + "\n", + "model = Word2Vec(walks, vector_size=128, window=5, min_count=0, sg=1, workers=2, epochs=1)\n", + "print('shape:', model.wv.vectors.shape)\n", + "model.wv.most_similar('t1')" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/Caskroom/miniforge/base/envs/py38/lib/python3.8/site-packages/sklearn/manifold/_t_sne.py:780: FutureWarning: The default initialization in TSNE will change from 'random' to 'pca' in 1.2.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA44AAAOVCAYAAAAm5r7MAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAwRklEQVR4nO3de7RlZ13n6++vLqncb6QIuSdAogalg9TBK14aELARxLZp6G4EtQ2MIee0R2xFsY80Q1obRc+xtdEgKE0rEkUEEW1AvA4FCRAxJFySkECKXIoEkhCSSl3e88eaRa8qqn5Vldq71t6p5xljj1rrnWvN+e6ae+3anz3nmlVjjAAAAMC+rFn0BAAAAFjZhCMAAAAt4QgAAEBLOAIAANASjgAAALSEIwAAAC3hCLBKVdWoqkcehu2cW1VfqKq1q2G9B7Dd06vqr6vq7qp61QE+54aqeuJyz+1grYR5VdX509fiuiVa3z4/p6r6tqq6ae7+R6rq25ZiuwD0hCPAClBVG6rqtVV14xQ0V1bVUxc9ryQZY3xqjHH8GGPHoaxnzyBYqvU+AJcm+WySE8cYL95zYVX9dlX97GGeEw/AGONRY4y/XPQ8AI4EwhFgZViX5NNJvjXJSUl+OsnlVXX+cm94qY4UrSLnJbl6jDEWPREAWC2EI8AKMMa4Z4zxsjHGDWOMnWOMtyf5ZJLH7npMVf3Hqrq5qj5TVT/Qra+q/rKqfq6q/qGq7qqqt1bVqdOyXacW/mBVfSrJe6pqTVX99HTE87aq+h9VddIej1833T9pOjp6c1VtrqqfnT/dtKp+qKqumY6cXl1VX1tVb0hybpI/nk5P/fG9rPfMqnpbVd1RVddW1Q/NrfNlVXX5NK+7p1MUNzWf/zdW1fur6s7pz2+cxn87yfOS/Pg0jyfu8bxLk/zbueV/PLf4kqr68LTON1XV0XPPe9p0lPjzVfV3VfXoZm6jql5YVZ+YHv9rVVXTsn3uh2n5c6dlt1fVS/dY75qqeklVXTctv3zXPt/HPPY55+no8H+cPt97pv19elX96fT3/+6qOmWPVf7A9LV5c1X92IHOaz+f0zE1OwL8uaq6Osn/scfyLx3F3t/XyPR1+KFp2e9P+/Bnp2WnVdXbp7+LO6rqb6rKz0gAc3xTBFiBqur0JBcl+ch0/ylJfizJk5JcmORA3tf2fUl+IMkZSbYn+ZU9ln9rkq9K8uQkz58+vj3Jw5Mcn+RX97He357W98gkj0nyHUn+/TTPf5XkZdO2T0zy9CS3jzGem+RTSb5rOj31lXtZ7+8luSnJmUm+N8l/qap/Prf86dNjTk7ytn3Nb4qSP5k+34ck+aUkf1JVDxljPD/J7yR55TSPd88/d4xx2R7Lv2tu8bOSPCXJBUkePf19paoek+R1SV4wbe83krytqjbsbX6Tp2UWQY+e1vvkafz52cd+qKqLk7w6yXOnv6OHJDl7bp3/Z5Lvzmy/npnkc0l+bR9/Rwcy53+Z2dfbRUm+K8mfJvmpJBsz+/nh/9pjtd+e2dfmdyT5ibko3+e8DuBz+pkkj5g+npxZ9Hf2+jVSVUcleUtmX7unJnljkmfOPe/FmX3tbUxy+vR5OiINMEc4AqwwVbU+s3h5/Rjjo9Pws5L81hjjqjHGPZnF2f68Ye7x/ynJs2r3C9G8bDrSeW9mR9l+aYxx/RjjC0l+Msmza4/TWKeg/c4kPzI997Ykv5zk2dND/n1m0fX+MXPtGOPGA/icz0nyTUl+Yoxx3xjjyiS/mVmA7vK3Y4x3TO+JfEOSf7aP1f2LJJ8YY7xhjLF9jPHGJB/NLH4Oxa+MMT4zxrgjyR8nuWQavzTJb4wx3jfG2DHGeH2SrUm+vlnXz48xPj/G+FSSv5hbV7cfvjfJ28cYfz3G2JrZPt05t84XJnnpGOOmafnLknzvnvvwIOb838YYt44xNif5myTvG2N8aIxxX2YR9pg91vmfp6+Jf0ryW0mecwDz2t/n9Kwkrxhj3DHG+HS+/Jcfe9rX18jXZ3Y6+K+MMbaNMf4wyT/MPW9bZr9gOW9a/jdOZQbYnXAEWEGm0+PekOT+JC+aW3RmZu+B3GW/MbaXx69Pcto+lp+5xzpvzOwH7dP3WOd503punk7r+3xmR6seOi0/J8l1BzC3PZ2Z5I4xxt17zOGsufu3zN3+YpKj9xFFe34ue1vXA7Hn9o+fbp+X5MW7/j6mv5Nzpnkc7Lq6/bDb18D0C4Hb5x57XpK3zM3hmiQ78uX78EDnfOvc7Xv3cv/47G7Pr7dd6+rmtb/P6WC/7vf1NXJmks17xOD8en8hybVJ3llV11fVS/azHYAjjnAEWCGm97m9NrMfqP/lGGPb3OKbM/vBfpdzD2CVez5+W2ZXE91l/ofoz2T2A/7847dn91hIZj9sb01y2hjj5OnjxDHGo+aWP2If8+mO4HwmyalVdcIec9jcPKdb13l7jB3Mug72SNOnMzsqdvLcx7HTkc6D1e2H3b4GqurYzE7tnJ/HU/eYx9HTEcPlnPMue369feYA5rW/z+mBfN3vzc1Jztr1XtI95zvGuHuM8eIxxsMzO931R6vqCQ9wWwAPSsIRYOV4dWbvOfyu6fTReZcneX5VXTz9cP0zB7C+fzf3+Jcn+YPmv754Y5L/u6ouqKrjk/yXJG8aY2yff9AY4+Yk70zyqqo6cbrwySOq6lunh/xmkh+rqsfWzCOralcI3ZrZ+/a+zHQa4t8l+bmqOnq6UMsPJvmfB/B57ukdSS6qqn9TVeuq6l8nuTjJ2w/w+fuc5z68JskLq+rrps/5uKr6F3tE8IHq9sMfJHlaVX3z9J69l2f3f8d/Pckrdv19V9XGqnrGYZjzLv+pqo6tqkcl+f4kbzqAee3vc7o8yU9W1SlVdXZm75d8IP4+s6OcL5q+Jp6R5HG7FtbsQkGPnMLyzumxO/e+KoAjk3AEWAGmH6pfkNl73W6p2RU9v1BV/zZJxhh/muT/TfKezE6pe88BrPYNmV0M5JYkR+fLL2Yy73XT4/86s6u53pd9/5D+fUmOSnJ1Zhc6+YPM3h+WMcbvJ3lFkt9NcneSP8rsYiRJ8nNJfno6ZfHH8uWek+T8zI5UvSXJz+x58ZoDMca4PbOLz7w4s9MefzzJ08YYn22f+L+9NsnF0zz/6AC2d0WSH8rsQiyfy2z/PP9g5z3Z534YY3wkyQ9n9nd787Stm+ae+/9ldkGYd1bV3Unem+TrDsOcd/mraT1/nuQXxxjv3N+8DuBz+s+ZnZ76ycx+YfGGBzKxMcb9Sb4ns19GfD7Jv8vsFwlbp4dcmOTdSb6QWWT+9zHGXzyQbQE8WJX3fgM8+FTVXyb5n2OM31yCdT08yceTrHfBEB4squp9SX59jPFbi54LwGrgiCMA+/PVSW4UjaxmVfWtVfWw6VTV52X2X6H82aLnBbBa7O1qdACQJKmqH83sVM8H+t4yWCm+IrP3TB6X5Pok3zu9ZxeAA+BUVQAAAFpOVQUAAKAlHAEAAGitqPc4nnbaaeP8889f9DQAAACOSB/4wAc+O8bYuOf4igrH888/P1dcccWipwEAAHBEqqob9zbuVFUAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgNZBhWNVva6qbquqq+bGTq2qd1XVJ6Y/T5nGq6p+paquraoPV9XXLvXkAQAAWH4He8Txt5M8ZY+xlyT58zHGhUn+fLqfJE9NcuH0cWmSVz/waQIAALAoBxWOY4y/TnLHHsPPSPL66fbrk3z33Pj/GDPvTXJyVZ1xCHMFAABgAZbiPY6njzFunm7fkuT06fZZST4997ibpjEAAABWkSW9OM4YYyQZB/Ocqrq0qq6oqiu2bNmylNMBAABgCSxFON666xTU6c/bpvHNSc6Ze9zZ09huxhiXjTE2jTE2bdy4cQmmAwAAwFJainB8W5LnTbefl+Stc+PfN11d9euT3Dl3SisAAACrxLqDeXBVvTHJtyU5rapuSvIzSX4+yeVV9YNJbkzyrOnh70jynUmuTfLFJN+/RHMGAADgMDqocBxjPGcfi56wl8eOJD/8QCYFAADAyrGkF8cBAADgwUc4AgAA0BKOAAAAtIQjAAAALeEIAABASzgCAADQEo4AAAC0Dur/cQSA5XLPXV/MdVfekNtu3JJjTjgmj3zMBTn9vI2LnhYAEEccAVgB7v3CvfnbP3xfbvr4Z3LUsRty3z1b8/d//P586qM3LXpqAECEIwArwI3XbM72bdtzyuknZ/1R63Lsicfk1Iedkqv//uPZsX3HoqcHAEc84QjAwt2++Y4cc/wxu42t37A+2+7fnq333r+gWQEAuwhHABbupI0n5r57tu42tmP7jqxduyZHHb1+QbMCAHYRjgAs3HkXn52dO3bknju/mCTZtnVbPrv5jjzyMRdk3XrXcQOARROOACzcCaccn2/67sfl6OM25LM33Z57v3BfvuZbviqPfMwFi54aABD/HQcAK8Qpp5+cb37m12X7tu1Zs3ZN1qzxu00AWCmEIwArilNTAWDl8etcAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgNa6Q11BVX1FkjfNDT08yf+T5OQkP5RkyzT+U2OMdxzq9gAAADi8DjkcxxgfS3JJklTV2iSbk7wlyfcn+eUxxi8e6jYAAABYnKU+VfUJSa4bY9y4xOsFAABgQZY6HJ+d5I1z919UVR+uqtdV1SlLvC0AAAAOgyULx6o6KsnTk/z+NPTqJI/I7DTWm5O8ah/Pu7SqrqiqK7Zs2bK3hwAAALBAS3nE8alJPjjGuDVJxhi3jjF2jDF2JnlNksft7UljjMvGGJvGGJs2bty4hNMBAABgKSxlOD4nc6epVtUZc8uemeSqJdwWAAAAh8khX1U1SarquCRPSvKCueFXVtUlSUaSG/ZYBgAAwCqxJOE4xrgnyUP2GHvuUqwbAACAxVrqq6oCAADwICMcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaK1bqhVV1Q1J7k6yI8n2Mcamqjo1yZuSnJ/khiTPGmN8bqm2CQAAwPJb6iOO3z7GuGSMsWm6/5Ikfz7GuDDJn0/3AQAAWEWW+1TVZyR5/XT79Um+e5m3BwAAwBJbynAcSd5ZVR+oqkunsdPHGDdPt29JcvoSbg8AAIDDYMne45jkm8cYm6vqoUneVVUfnV84xhhVNfZ80hSZlybJueeeu4TTAQAAYCks2RHHMcbm6c/bkrwlyeOS3FpVZyTJ9Odte3neZWOMTWOMTRs3blyq6QAAALBEliQcq+q4qjph1+0k35HkqiRvS/K86WHPS/LWpdgeAAAAh89Snap6epK3VNWudf7uGOPPqur9SS6vqh9McmOSZy3R9gAAADhMliQcxxjXJ/lnexm/PckTlmIbAAAALMZy/3ccAAAArHLCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoLVu0RMAAAB4sBvj3oztm5Nxb2rtxmTNQ1O1eo7jCUcAAIBlNHbcnrH1PUm2JWNdxrZ/TNaen2z4hlStXfT0DohwBAAAWCZjjIz735tkQ2rNQ/73+I5PZmw/J7X+vMVN7iCsnmOjAAAAq834QjLuTK05fvfxOiHZeeNi5vQACEcAAIBlsyYZsyOPu9uZZP0iJvSACEcAAIBlUmuOS9Y+LNl5x5fGxtiRjC+m1l2wwJkdHOEIAACwjOqor0/WnpSx45aMHbckOz+bHPW1qbUPW/TUDpiL4wAAACyjWnNssuFJ01HH+5M6aTa2ighHAACAZVZVydqH7P+BK5RTVQEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFqHHI5VdU5V/UVVXV1VH6mq/zCNv6yqNlfVldPHdx76dAEAADjc1i3BOrYnefEY44NVdUKSD1TVu6ZlvzzG+MUl2AYAAAALcsjhOMa4OcnN0+27q+qaJGcd6noBAABYGZb0PY5VdX6SxyR53zT0oqr6cFW9rqpOWcptAQAAcHgsWThW1fFJ3pzkR8YYdyV5dZJHJLkksyOSr9rH8y6tqiuq6ootW7Ys1XQAAABYIksSjlW1PrNo/J0xxh8myRjj1jHGjjHGziSvSfK4vT13jHHZGGPTGGPTxo0bl2I6AAAALKGluKpqJXltkmvGGL80N37G3MOemeSqQ90WAAAAh99SXFX1m5I8N8k/VdWV09hPJXlOVV2SZCS5IckLlmBbAAAAHGZLcVXVv01Se1n0jkNdNwAAAIu3pFdVBQAA4MFHOAIAANASjgAAALSEIwAAAC3hCAAAQEs4AgAA0BKOAAAAtIQjAAAALeEIAABASzgCAADQEo4AAAC0hCMAAAAt4QgAAEBLOAIAANASjgAAALSEIwAAAC3hCAAAQEs4AgAA0BKOAAAAtIQjAAAALeEIAABASzgCAADQEo4AAAC0hCMAAAAt4QgAAEBLOAIAANASjgAAALSEIwAAAC3hCAAAQEs4AgAA0BKOAAAAtIQjAAAALeEIAABASzgCAADQEo4AAAC0hCMAAAAt4QgAAEBr3aInsNKNsTPZeVvGjluS2pBae05qzfGLnhYAAMBhIxwbY+zMuP/vk+2fTOroZGzPyJUZG741a9aduejpAQAAHBZOVe3svCXZfn2y5ozUmlNTax+arDkpuf/vMsb2Rc8OAADgsBCOjbH9pqSOTVV9aazq6GRsS8ZdC5wZAADA4SMcO3VUMnbsZcFIsvZwzwYAAGAhhGOj1p2b1LaMse1LY2PnHcna05I6cYEzAwAAOHyEY6PWnJqs/4ZkfD5j563TlVWPTx31jbudvgoAAPBg5qqq+7Fm/cMz1p2d7PxcUuuTOkU0AgAARxTheACqjkrWnr7oaQAAACyEU1UBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKC17OFYVU+pqo9V1bVV9ZLl3h4AAABLa1nDsarWJvm1JE9NcnGS51TVxcu5TQAAAJbWch9xfFySa8cY148x7k/ye0mesczbBAAAYAmtW+b1n5Xk03P3b0rydcu8TQBY9e66/e5c/0835vO33ZlTHnpSLnj0eTnx1BMWPS0AjlALvzhOVV1aVVdU1RVbtmxZ9HQAYOE+d9ud+es/+Pvccv1tqap85vrb8jdvfl8+v+XORU8NgCPUcofj5iTnzN0/exr7kjHGZWOMTWOMTRs3blzm6QDAyvexf7g2Rx1zVE7aeGKOOvqonLzxxKw/al0+fsV1i54aAEeo5Q7H9ye5sKouqKqjkjw7yduWeZsAsKp99qbbc/zJx+02dtxJx2bLTXcsaEYAHOmWNRzHGNuTvCjJ/0pyTZLLxxgfWc5tAsBqd9zJx2brvffvNrb13vu/LCYB4HBZ9vc4jjHeMca4aIzxiDHGK5Z7ewCw2l206RG5a8tduX/rtiTJ/ffdn7tvvzsXbXr4gmcGwJFq4RfHAQB2d9Yjz8hjnvg12frFrfnsZ+7I1nvvz9c+6dE544LTFz01AI5Qy/3fcQAAD8C5X3l2zr7ozGzbui3rN6zPmjV+1wvA4ghHAFih1qxZkw3HbFj0NADAqaoAAAD0hCMAAAAt4QgAAEBLOAIAANASjgAAALSEIwAAAC3hCAAAQEs4AgAA0BKOAAAAtIQjAAAALeEIAABASzgCAADQEo4AAAC0hCMAAAAt4QgAAEBLOAIAANASjgAAALSEIwAAAC3hCAAAQEs4AgAA0BKOAAAAtIQjAAAALeEIAABASzgCAADQEo4AAAC0hCMAAAAt4QgAAEBLOAIAANASjgAAALSEIwAAAC3hCAAAQEs4AgAA0BKOAAAAtIQjAAAALeEIAABASzgCAADQEo4AAAC0hCMAAAAt4QgAAEBLOAIAANASjgAAALSEIwAAAC3hCAAAQEs4AgAA0BKOAAAAtIQjAAAALeEIAABASzgCAADQEo4AAAC0hCMAAAAt4QgAAEBLOAIAANASjgAAALSEIwAAAC3hCAAAQEs4AgAA0BKOAAAAtIQjAAAALeEIAABASzgCAADQEo4AAAC0hCMAAAAt4QgAAEBLOAIAANASjgAAALSEIwAAAC3hCAAAQEs4AgAA0BKOAAAAtIQjAAAALeEIAABASzgCAADQEo4AAAC0hCMAAAAt4QgAAEBLOAIAANASjgAAALSEIwAAAC3hCAAAQEs4AgAA0BKOAAAAtIQjAAAALeEIAABASzgCAADQEo4AAAC0hCMAAAAt4QgAAEBLOAIAANASjgAAALSEIwAAAC3hCAAAQEs4AgAA0BKOAAAAtIQjAAAALeEIAABA65DCsap+oao+WlUfrqq3VNXJ0/j5VXVvVV05ffz6kswWAACAw+5Qjzi+K8lXjzEeneTjSX5ybtl1Y4xLpo8XHuJ2AAAAWJBDCscxxjvHGNunu+9NcvahTwkAAICVZCnf4/gDSf507v4FVfWhqvqrqnr8Em4HAACAw2jd/h5QVe9O8rC9LHrpGOOt02NemmR7kt+Zlt2c5Nwxxu1V9dgkf1RVjxpj3LWX9V+a5NIkOffccx/YZwEAAMCy2W84jjGe2C2vqucneVqSJ4wxxvScrUm2Trc/UFXXJbkoyRV7Wf9lSS5Lkk2bNo2DnD8AAADL7FCvqvqUJD+e5OljjC/OjW+sqrXT7YcnuTDJ9YeyLQAAABZjv0cc9+NXk2xI8q6qSpL3TldQ/ZYkL6+qbUl2JnnhGOOOQ9wWAAAAC3BI4TjGeOQ+xt+c5M2Hsm4AAABWhqW8qioAAAAPQsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACA1iGFY1W9rKo2V9WV08d3zi37yaq6tqo+VlVPPvSpAgAAsAjrlmAdvzzG+MX5gaq6OMmzkzwqyZlJ3l1VF40xdizB9gAAADiMlutU1Wck+b0xxtYxxieTXJvkccu0LQAAAJbRUoTji6rqw1X1uqo6ZRo7K8mn5x5z0zQGAADAKrPfcKyqd1fVVXv5eEaSVyd5RJJLktyc5FUHO4GqurSqrqiqK7Zs2XKwTwcAAGCZ7fc9jmOMJx7IiqrqNUnePt3dnOScucVnT2N7W/9lSS5Lkk2bNo0D2RYAAACHz6FeVfWMubvPTHLVdPttSZ5dVRuq6oIkFyb5h0PZFgAAAItxqFdVfWVVXZJkJLkhyQuSZIzxkaq6PMnVSbYn+WFXVAUAAFidDikcxxjPbZa9IskrDmX9AAAALN5y/XccAAAAPEgIRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoLVu0RMAAABWp53bP51suyYZ9yRrz0qt/6rUmhMWPS2WgSOOAADAQdu57RPJ1r9Ixtakjk2235Bx3zszdt6z6KmxDIQjAABwUMbYnmz7x2TN6ak1x6VqfWrtacnYlrH9ukVPj2UgHAEAgIMz7kuyLVXrdx+v45IdWxYyJZaXcAQAAA5ObUiyNmPs2H183JesPWUhU2J5CUcAAOCgVK1P1l2c7LwlY9yfMUbGzruS7Eyte+Sip8cycFVVAADgoNX6izNqXbLt6iT3JWsemlr/+NSaExc9NZaBcAQAAA5a1ZrU+q/MWPcVSXamau2ip8QyEo4AAMADVlVJROODnfc4AgAA0BKOAAAAtIQjAAAALeEIAABASzgCAADQEo4AAAC0hCMAAAAt4QgAAEBLOAIAANASjgAAALSEIwAAAC3hCAAAQEs4AgAA0Fp3KE+uqjcl+Yrp7slJPj/GuKSqzk9yTZKPTcveO8Z44aFsCwAAgMU4pHAcY/zrXber6lVJ7pxbfN0Y45JDWT8AAACLd0jhuEtVVZJnJfnnS7E+AAAAVo6leo/j45PcOsb4xNzYBVX1oar6q6p6/BJtBwAAgMNsv0ccq+rdSR62l0UvHWO8dbr9nCRvnFt2c5Jzxxi3V9Vjk/xRVT1qjHHXXtZ/aZJLk+Tcc8892PkDAACwzPYbjmOMJ3bLq2pdku9J8ti552xNsnW6/YGqui7JRUmu2Mv6L0tyWZJs2rRpHMzkAQAAWH5LcarqE5N8dIxx066BqtpYVWun2w9PcmGS65dgWwAAABxmS3FxnGdn99NUk+Rbkry8qrYl2ZnkhWOMO5ZgWwAAABxmhxyOY4zn72XszUnefKjrBgAAYPGW6qqqAAAAPEgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHAEAAGgJRwAAAFrCEQAAgJZwBAAAoCUcAQAAaAlHAAAAWsIRAACAlnAEAACgJRwBAABoCUcAAABawhEAAICWcAQAAKAlHIFV4/777s/dn/tCtm/bvuipAAAcUdYtegIA+7Nj+45c875P5IarPpUkWbtubS7+hoty3sXnLHhmAABHBuEIrHif+OD1uf4fb8xDzjwla9auybb7t+dD77kqx5xwTB56zmmLnh4AwIOeU1WBFW3H9h25/sM35tQzTs6atbNvWeuPWpfjTjo2n/zwjQueHQDAkUE4Aivaju07smP7zqxdt3a38fUb1ufeL9y3oFkBABxZhCOwoq3fsD4nnXZC7rnri7uN3/P5e3L6BQ9d0KwAAI4swhFY0aoqX/3NX5n77tmaz916Z+6564u5/TN35Jjjj875j3JxHACAw8HFcYAV79SHnZJve9Y35tMf3Zy7P3dPHv415+WsCx+WDcdsWPTUAACOCMIRWBWOP/m4fNXXX7ToaQAAHJGcqgoAAEBLOAIAANASjgAAALSEIwAAAC3hCAAAQEs4AgAA0BKOAAAAtIQjAAAALeEIAABASzgCAADQEo4AAAC0hCMAAAAt4QgAAEBLOAIAANASjgAAALSEIwAAAC3hCAAAQEs4AgAA0BKOAAAAtIQjAAAALeEIAABASzgCAADQEo4AAAC0hCMAAAAt4QgAAEBLOAIAANASjgAAALSEIwAAAC3hCAAAQEs4AgAA0BKOAAAAtIQjAAAALeEIAABASzgCAADQEo4AAAC0aoyx6Dl8SVVtSXLjoufxIHNaks8uehIcEPtq9bCvVhf7a/Wwr1YP+2r1sK9Wj5Wyr84bY2zcc3BFhSNLr6quGGNsWvQ82D/7avWwr1YX+2v1sK9WD/tq9bCvVo+Vvq+cqgoAAEBLOAIAANASjg9+ly16Ahww+2r1sK9WF/tr9bCvVg/7avWwr1aPFb2vvMcRAACAliOOAAAAtITjg0hV/auq+khV7ayqTXss+8mquraqPlZVT54bf8o0dm1VveTwz5qqelNVXTl93FBVV07j51fVvXPLfn3BUz3iVdXLqmrz3D75zrlle32NsRhV9QtV9dGq+nBVvaWqTp7Gva5WIP8WrVxVdU5V/UVVXT39jPEfpvF9fj9kcaafI/5p2idXTGOnVtW7quoT05+nLHqeR7qq+oq5186VVXVXVf3ISn9dOVX1QaSqvirJziS/keTHxhi7vmFcnOSNSR6X5Mwk705y0fS0jyd5UpKbkrw/yXPGGFcf5qkzqapXJblzjPHyqjo/ydvHGF+94GkxqaqXJfnCGOMX9xjf62tsjLHjsE+SJElVfUeS94wxtlfVf02SMcZPeF2tPFW1Nv4tWrGq6owkZ4wxPlhVJyT5QJLvTvKs7OX7IYtVVTck2TTG+Ozc2CuT3DHG+PnpFzOnjDF+YlFzZHfT98DNSb4uyfdnBb+uHHF8EBljXDPG+NheFj0jye+NMbaOMT6Z5NrMfsB9XJJrxxjXjzHuT/J702NZgKqqzP4hfuOi58JB29drjAUZY7xzjLF9uvveJGcvcj60/Fu0go0xbh5jfHC6fXeSa5KctdhZcZCekeT10+3XZxb+rBxPSHLdGOPGRU9kf4TjkeGsJJ+eu3/TNLavcRbj8UluHWN8Ym7sgqr6UFX9VVU9flETYzcvmk5/fN3c6T5eSyvbDyT507n7Xlcri9fPKjEdsX9MkvdNQ3v7fshijSTvrKoPVNWl09jpY4ybp9u3JDl9MVNjH56d3Q8arNjXlXBcZarq3VV11V4+/HZ2BTvA/fac7P6N4+Yk544xHpPkR5P8blWdeDjnfSTaz756dZJHJLkks/3zqkXO9Uh3IK+rqnppku1Jfmca8rqCB6Cqjk/y5iQ/Msa4K74frlTfPMb42iRPTfLDVfUt8wvH7D1q3qe2QlTVUUmenuT3p6EV/bpat+gJcHDGGE98AE/bnOScuftnT2NpxllC+9tvVbUuyfckeezcc7Ym2Trd/kBVXZfZe1OvWMapHvEO9DVWVa9J8vbpbvcaY5kcwOvq+UmeluQJ0w9LXlcrk9fPCldV6zOLxt8ZY/xhkowxbp1bPv/9kAUaY2ye/rytqt6S2angt1bVGWOMm6f3rN620Eky76lJPrjr9bTSX1eOOB4Z3pbk2VW1oaouSHJhkn/I7AIEF1bVBdNvPJ49PZbD74lJPjrGuGnXQFVtnN4wnap6eGb77foFzY986SIRuzwzyVXT7X29xliQqnpKkh9P8vQxxhfnxr2uVh7/Fq1g0/vvX5vkmjHGL82N7+v7IQtSVcdNFzBKVR2X5Dsy2y9vS/K86WHPS/LWxcyQvdjtbLOV/rpyxPFBpKqemeS/JdmY5E+q6soxxpPHGB+pqsuTXJ3ZKVs/vOtqj1X1oiT/K8naJK8bY3xkQdM/0u15fnuSfEuSl1fVtsyulvvCMcYdh31mzHtlVV2S2Wk+NyR5QZJ0rzEW5leTbEjyrtnPvXnvGOOF8bpacaYr3/q3aOX6piTPTfJPNf13UUl+Kslz9vb9kIU6Pclbpu9565L87hjjz6rq/Ukur6ofTHJjZhfiY8GmuH9Sdn/t7PXnjJXCf8cBAABAy6mqAAAAtIQjAAAALeEIAABASzgCAADQEo4AAAC0hCMAAAAt4QgAAEBLOAIAAND6/wEYBBJMyhUisQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# viz\n", + "\n", + "node_embeddings = model.wv.vectors\n", + "node_types = [G.node_type(node_id) for node_id in model.wv.index_to_key]\n", + "\n", + "from sklearn.manifold import TSNE\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "node_embeddings_2d = TSNE(n_components=2, learning_rate='auto').fit_transform(node_embeddings)\n", + "node_embeddings_2d\n", + "\n", + "label_map = {l: i for i, l in enumerate(np.unique(node_types))}\n", + "node_colors = [label_map[t] for t in node_types]\n", + "\n", + "plt.figure(figsize=(20, 16))\n", + "plt.axes().set(aspect=\"equal\")\n", + "plt.scatter(node_embeddings_2d[:, 0], node_embeddings_2d[:, 1], c=node_colors, alpha=0.3)\n", + "plt.title('2d projection of the node embeddings')\n", + "plt.show()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "4bc0b60e31b0a7441a2e25ec194980ab62b84e91a65eae3f6b114824d9f7dec0" + }, + "kernelspec": { + "display_name": "Python 3.8.12 64-bit ('py38': conda)", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/node2vec.ipynb b/node2vec.ipynb deleted file mode 100644 index c78c6e1..0000000 --- a/node2vec.ipynb +++ /dev/null @@ -1,257 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Note: you may need to restart the kernel to use updated packages.\n" - ] - } - ], - "source": [ - "# %conda activate py38\n", - "%pip install stellargraph chardet -Uq" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "%reload_ext autoreload\n", - "%autoreload 2\n", - "\n", - "import stellargraph as sg\n", - "import pandas as pd" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "StellarGraph: Undirected multigraph\n", - " Nodes: 6, Edges: 5\n", - "\n", - " Node types:\n", - " task: [3]\n", - " Features: float32 vector, length 1\n", - " Edge types: task-default->construct, task-default->task\n", - " construct: [3]\n", - " Features: float32 vector, length 1\n", - " Edge types: construct-default->construct, construct-default->task\n", - "\n", - " Edge types:\n", - " task-default->task: [2]\n", - " Weights: range=[1, 2], mean=1.5, std=0.707107\n", - " Features: none\n", - " construct-default->construct: [2]\n", - " Weights: range=[10, 12], mean=11, std=1.41421\n", - " Features: none\n", - " construct-default->task: [1]\n", - " Weights: all 10\n", - " Features: none\n" - ] - } - ], - "source": [ - "tasks = pd.DataFrame(\n", - " [10,20,30],\n", - " index = ['t1','t2','t3']\n", - ")\n", - "\n", - "constructs = pd.DataFrame(\n", - " [50,60,70],\n", - " index = ['c1','c2','c3']\n", - ")\n", - "\n", - "edges = pd.DataFrame(\n", - " {'source': ['t1', 't2', 'c1', 'c2', 't1'],\n", - " 'target': ['t2', 't3', 'c2', 'c1', 'c1'],\n", - " 'weight': [1, 2, 10, 12, 10]},\n", - ")\n", - "\n", - "G = sg.StellarGraph({'task': tasks, 'construct': constructs}, edges=edges)\n", - "print(G.info())\n" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of random walks: {len(walks)}\n" - ] - }, - { - "data": { - "text/plain": [ - "[['c1', 'c2', 'c1', 'c2', 'c1'],\n", - " ['c2', 'c1', 'c2', 'c1', 'c2'],\n", - " ['c3'],\n", - " ['t1', 'c1', 't1', 'c1', 't1'],\n", - " ['t1', 'c1', 'c2'],\n", - " ['t2'],\n", - " ['t2'],\n", - " ['t3'],\n", - " ['t3']]" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# metapath2vec\n", - "\n", - "rnd_walk_length = 5 # maximum length of a random walk\n", - "\n", - "# metapath schemas as a list of lists of node types.\n", - "metapaths = [\n", - " ['task', 'construct', 'task'],\n", - " ['construct', 'construct'],\n", - " ['task', 'construct', 'construct', 'task'],\n", - "]\n", - "\n", - "\n", - "from stellargraph.data import UniformRandomMetaPathWalk\n", - "\n", - "rw = UniformRandomMetaPathWalk(G)\n", - "\n", - "walks = rw.run(\n", - " nodes=list(G.nodes()), # root nodes\n", - " length=rnd_walk_length, # maximum length of a random walk\n", - " n=1, # number of random walks per root node\n", - " metapaths=metapaths, # the metapaths\n", - ")\n", - "\n", - "print('Number of random walks: {len(walks)}')\n", - "walks" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "shape: (6, 128)\n" - ] - }, - { - "data": { - "text/plain": [ - "[('c1', 0.0630912259221077),\n", - " ('t2', 0.02670864760875702),\n", - " ('t3', -0.016970207914710045),\n", - " ('c2', -0.07985257357358932),\n", - " ('c3', -0.15879441797733307)]" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from gensim.models import Word2Vec\n", - "\n", - "model = Word2Vec(walks, vector_size=128, window=5, min_count=0, sg=1, workers=2, epochs=1)\n", - "print('shape:', model.wv.vectors.shape)\n", - "model.wv.most_similar('t1')" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/Caskroom/miniforge/base/envs/py38/lib/python3.8/site-packages/sklearn/manifold/_t_sne.py:780: FutureWarning: The default initialization in TSNE will change from 'random' to 'pca' in 1.2.\n", - " warnings.warn(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# viz\n", - "\n", - "node_embeddings = model.wv.vectors\n", - "node_types = [G.node_type(node_id) for node_id in model.wv.index_to_key]\n", - "\n", - "from sklearn.manifold import TSNE\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "\n", - "node_embeddings_2d = TSNE(n_components=2, learning_rate='auto').fit_transform(node_embeddings)\n", - "node_embeddings_2d\n", - "\n", - "label_map = {l: i for i, l in enumerate(np.unique(node_types))}\n", - "node_colors = [label_map[t] for t in node_types]\n", - "\n", - "plt.figure(figsize=(20, 16))\n", - "plt.axes().set(aspect=\"equal\")\n", - "plt.scatter(node_embeddings_2d[:, 0], node_embeddings_2d[:, 1], c=node_colors, alpha=0.3)\n", - "plt.title('2d projection of the node embeddings')\n", - "plt.show()" - ] - } - ], - "metadata": { - "interpreter": { - "hash": "4bc0b60e31b0a7441a2e25ec194980ab62b84e91a65eae3f6b114824d9f7dec0" - }, - "kernelspec": { - "display_name": "Python 3.8.12 64-bit ('py38': conda)", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.12" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -}