docs/src/main/paradox/docs/getting-started/notebooks/MOOC_Content_based_Recommender_System_using_Blue_Brain_Nexus.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YoCPKFu5lpwU"
   },
   "source": [
    "# A simple pipeline for recommending similar neuroscience datasets using knowledge graph node embeddings\n",
    "\n",
    "In this tutorial, you will:\n",
    "\n",
    "1. Select a Blue Brain Nexus project from which to search neuron morphology and electrophysiology recordings \n",
    "2. Prepare the metadata for knowledge graph embeddings\n",
    "3. Train a knowledge graph node embedding model and embed each neuron morphology\n",
    "4. Store and index the embeddings in Blue Brain Nexus\n",
    "5. Recommend similar neuron morphologies and electrophysiology recordings using the embeddings \n",
    "\n",
    "\n",
    "### Prerequisites\n",
    "\n",
    "This notebook makes use of a dataset made of mouse neuron morphologies downloaded from Allen Cell Types Database and MouseLight as well as mouse electrophysiology recordings from Allen Cell Types Database. This dataset is expected to be accessible from a Blue Brain Nexus Project to be configured below. If not, please run the `Tutorial: Integrate Neuroscience Datasets from Multiple Sources using MINDS` [notebook](https://github.com/BlueBrain/nexus/blob/master/docs/src/main/paradox/docs/getting-started/notebooks/dataset_from_different_sources.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install pyRDF2vec\n",
    "!pip install nexusforge==0.7.0\n",
    "!pip install matplotlib\n",
    "!pip install validators\n",
    "!pip install gensim\n",
    "!pip install sklearn\n",
    "!pip install --upgrade nest-asyncio==1.5.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import getpass\n",
    "import json\n",
    "import requests\n",
    "import time\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from community import community_louvain\n",
    "\n",
    "from pathlib import Path\n",
    "\n",
    "from kgforge.core import KnowledgeGraphForge\n",
    "\n",
    "import nexussdk as nexus\n",
    "\n",
    "from pyrdf2vec import RDF2VecTransformer\n",
    "from pyrdf2vec.graphs import KG\n",
    "from pyrdf2vec.graphs.vertex import Vertex\n",
    "from pyrdf2vec.walkers import WLWalker\n",
    "from pyrdf2vec.samplers import ObjFreqSampler\n",
    "\n",
    "from sklearn.manifold import TSNE\n",
    "from sklearn.impute import SimpleImputer\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from urllib.parse import quote_plus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "## Select a Blue Brain Nexus project from which to search neuron morphology and electrophysiology recordings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8dFPUxxP7cWA"
   },
   "source": [
    "### Initialize and configure a client to access a Blue Brain Nexus Project"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get an authentication token"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [Nexus sandbox application](https://sandbox.bluebrainnexus.io) can be used to get a token:\n",
    "\n",
    "- Step 1: From the [web page](https://sandbox.bluebrainnexus.io), click on the login button in the top right corner and follow the instructions on screen.\n",
    "\n",
    "- Step 2: You will then see a `Copy token` button in the top right corner. Click on it to copy the token to the clipboard.\n",
    "\n",
    "Once a token is obtained, proceed to paste it as the value of the `TOKEN` variable below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TOKEN = getpass.getpass()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Configure a forge client to store, manage and access datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = requests.get('https://raw.githubusercontent.com/BlueBrain/nexus/ef830192d4e7bb95f9351c4bdab7b0114c27e2f0/docs/src/main/paradox/docs/getting-started/notebooks/rdfmodel/jsonldcontext.json')\n",
    "dirpath = './rdfmodel'\n",
    "Path(dirpath).mkdir(parents=True, exist_ok=True)\n",
    "with open(f'{dirpath}/jsonldcontext.json', 'w') as outfile:\n",
    "    json.dump(r.json(), outfile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ENDPOINT = \"https://sandbox.bluebrainnexus.io/v1\"\n",
    "ORG = \"github-users\"\n",
    "PROJECT = \"\"  # Provide here the automatically created project name created when you logged into the Nexus sandbox instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "forge = KnowledgeGraphForge(\"https://raw.githubusercontent.com/BlueBrain/nexus/ef830192d4e7bb95f9351c4bdab7b0114c27e2f0/docs/src/main/paradox/docs/getting-started/notebooks/forge.yml\",\n",
    "                            bucket=f\"{ORG}/{PROJECT}\",\n",
    "                            endpoint=ENDPOINT,\n",
    "                            token=TOKEN)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wwenZHtmlpwW"
   },
   "source": [
    "### Search neuron morphology and electrophysiolgy recordings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "property_to_display = [\"id\",\"type\",\"@id\",\"@type\",\"name\",\"subject\",\"brainLocation.brainRegion.id\",\"brainLocation.brainRegion.label\",\"brainLocation.layer.id\",\"brainLocation.layer.label\", \"contribution.agent.label\",\"brainLocation.layer.id\",\"brainLocation.layer.label\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Search neuron morphologies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "_type = \"NeuronMorphology\"\n",
    "\n",
    "filters = {\"type\": _type}\n",
    "\n",
    "number_of_results = 20\n",
    "\n",
    "morphologies = forge.search(filters, limit=number_of_results)\n",
    "\n",
    "print(f\"{str(len(morphologies))} dataset(s) of type {_type} found\")\n",
    "\n",
    "reshaped_data = forge.reshape(morphologies, keep = property_to_display)\n",
    "\n",
    "morphologies_df = forge.as_dataframe(reshaped_data)\n",
    "morphologies_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Search electrophysiolgy recordings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "_type = \"Trace\"\n",
    "\n",
    "filters = {\"type\": _type}\n",
    "\n",
    "number_of_results = 20\n",
    "\n",
    "ephys = forge.search(filters, limit=number_of_results)\n",
    "\n",
    "print(f\"{str(len(ephys))} dataset(s) of type {_type} found\")\n",
    "\n",
    "reshaped_data = forge.reshape(ephys, keep = property_to_display)\n",
    "\n",
    "ephys_df = forge.as_dataframe(reshaped_data)\n",
    "ephys_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare the metadata for knowledge graph embeddings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this step, from the search results we generate a graph data structure to perform embedding on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We create a `KG` object to feed into a `pyrdf2vec` embedder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = ephys + morphologies\n",
    "graph = forge.as_graph(dataset)\n",
    "\n",
    "knowledge_graph = KG(\n",
    "    # These predicates will not be used during the embedding\n",
    "    skip_predicates={\n",
    "        \"http://www.w3.org/1999/02/22-rdf-syntax-ns#type\",\n",
    "        \"http://www.w3.org/2000/01/rdf-schema#label\",\n",
    "        \"http://schema.org/distribution\",\n",
    "        \"http://schema.org/identifier\",\n",
    "        \"http://schema.org/name\",\n",
    "        \"http://schema.org/description\",\n",
    "        \"https://neuroshapes.org/dateCreated\",\n",
    "    },\n",
    "    # These chains of predicates define literals that will not be used during the embedding,\n",
    "    # but will be further incorporated into the similarity search \n",
    "    literals=[\n",
    "        [\n",
    "            \"https://neuroshapes.org/brainLocation\",\n",
    "            \"https://neuroshapes.org/coordinatesInBrainAtlas\",\n",
    "            \"https://neuroshapes.org/valueX\",\n",
    "        ],\n",
    "        [\n",
    "            \"https://neuroshapes.org/brainLocation\",\n",
    "            \"https://neuroshapes.org/coordinatesInBrainAtlas\",\n",
    "            \"https://neuroshapes.org/valueY\",\n",
    "        ],\n",
    "        [\n",
    "            \"https://neuroshapes.org/brainLocation\",\n",
    "            \"https://neuroshapes.org/coordinatesInBrainAtlas\",\n",
    "            \"https://neuroshapes.org/valueZ\"\n",
    "        ]\n",
    "    ])\n",
    "\n",
    "for (s, p, o) in graph:\n",
    "    subj = Vertex(str(s))\n",
    "    obj = Vertex(str(o))\n",
    "    pred = Vertex(str(p), predicate=True, vprev=subj, vnext=obj)\n",
    "    knowledge_graph.add_walk(subj, pred, obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We select the Neuron Morphologies and Electrophysiology recordings to build embeddings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "entities = morphologies_df[\"id\"].tolist() + ephys_df[\"id\"].tolist()\n",
    "print(f\"{len(entities)} Neuron Morphologies and Electrophysiology recordings instances found\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "## Train a knowledge graph node embedding model and embed each neuron morphology and electrophysiology recordings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A knowledge graph embedding model represents each node (e.g. each Neuron Morphology or Electrophysiology Trace) in the graph with a numerical dense vector in a space with low dimensionality. The goal of such embedding is to place similar nodes closer in the resulting space. Similarity between two nodes can be computed using a distance score such as cosine similarity between their embedding vectors.\n",
    "\n",
    "For this tutorial, the [pyRDF2Vec](https://github.com/IBCNServices/pyRDF2Vec) will be used to generate embeddings for the selected Neuron Morphologies or Electrophysiology Traces.\n",
    "\n",
    "__Note__: Similarly to other machine learning tasks, graph embedding relies heavily on the provided dataset: the larger and richer the dataset is, the more accurate and meaningful embeddings can be constructed (and consequently their similarities). In this notebook we use a very small dataset of neuron morphologies and traces and build a 'toy' model serving as a proof of concept, rather than a real-world recommendation model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "walkers = [WLWalker(20, 100, ObjFreqSampler())]\n",
    "transformer = RDF2VecTransformer(walkers=walkers)\n",
    "embeddings, literals = transformer.fit_transform(\n",
    "    knowledge_graph, entities\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create numerical features from extracted literals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "features = pd.DataFrame(literals, columns=[\"X\", \"Y\", \"Z\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "features.sample(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Encode categorical features into vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def aggregate_vectors(x):\n",
    "    return [x.X] + [x.Y] + [x.Z]\n",
    "\n",
    "feature_vectors = features.apply(aggregate_vectors, axis=1).to_list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "imputer = SimpleImputer()\n",
    "feature_vectors = imputer.fit_transform(feature_vectors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Concatename produced embedding vectors with the feature vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_embeddings = [\n",
    "    np.hstack([embedding, feature_vectors[i]])\n",
    "    for i, embedding in enumerate(embeddings)\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualise the embeddings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reduce dimensionality of vectors to 2D in order to plot them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tsne_model = TSNE(perplexity=40, n_components=2, init='pca', n_iter=3000, random_state=23)\n",
    "embeddings_2D = tsne_model.fit_transform(final_embeddings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_embeddings(vectors, labels=None, title=None, ids=None):\n",
    "    unlabeled = False\n",
    "    if labels is None:\n",
    "        labels = [0] * len(vectors)\n",
    "        unlabeled = True\n",
    "\n",
    "    # Generate color map\n",
    "    unique_labels = set(labels)\n",
    "    cm = plt.get_cmap('gist_rainbow')\n",
    "    generated_colors = np.array([\n",
    "        cm(1. * i / len(unique_labels))\n",
    "        for i in range(len(unique_labels))\n",
    "    ])\n",
    "    np.random.shuffle(generated_colors)\n",
    "\n",
    "    alpha = 1\n",
    "    fig, ax = plt.subplots(figsize=(10, 10))\n",
    "\n",
    "    # create a scatter per node label\n",
    "    for i, l in enumerate(unique_labels):\n",
    "        indices = np.where(np.array(labels) == l)\n",
    "        ax.scatter(\n",
    "            vectors[indices, 0],\n",
    "            vectors[indices, 1],\n",
    "            c=[generated_colors[i]] * indices[0].shape[0],\n",
    "            cmap=\"jet\",\n",
    "            s=50,\n",
    "            alpha=alpha,\n",
    "            label=l if not unlabeled else None\n",
    "        )\n",
    "    if not unlabeled:\n",
    "        ax.legend(loc=\"center right\", bbox_to_anchor=(1.8, 0.5))\n",
    "\n",
    "    if ids is not None:\n",
    "        for i, el in enumerate(vectors):\n",
    "            plt.annotate(ids[i].split(\"/\")[-1], el)\n",
    "        \n",
    "    ax.set_title(title if title else \"2D visualization of the input node representation\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = morphologies_df[\"brainLocation.brainRegion.label\"].tolist() + ephys_df[\"brainLocation.brainRegion.label\"].tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_embeddings(\n",
    "    embeddings_2D, labels,\n",
    "    \"2D visualization of the node embedding (colors=brain regions)\",\n",
    "    ids=None)  # To show id's of points, set `ids=entities`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save the embeddings vectors and metadata to disk and in the Nexus project"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.concat([\n",
    "    morphologies_df[[\"id\", \"brainLocation.brainRegion.label\"]],\n",
    "    ephys_df[[\"id\", \"brainLocation.brainRegion.label\"]]\n",
    "]).rename(columns={\"id\": \"resource_id\", \"brainLocation.brainRegion.label\": \"brain_region\"}).to_csv(\n",
    "    \"metadata_rdf2vec_kg_embeddings.tsv\", sep=\"\\t\", index=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt(\"vectors_rdf2vec_kg_embeddings.tsv\", final_embeddings, delimiter=\"\\t\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Tip__: Try playing with the produced embeddings by loading the saved files in https://projector.tensorflow.org/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save the embedding model to disk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "transformer.embedder._model.save(\"./kg_embedding_model\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "## Store and index the embeddings in Blue Brain Nexus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Update morphology and electrophysiology resources with embedding vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for i, entity in enumerate(entities):\n",
    "    resource = forge.retrieve(entity)\n",
    "    resource.embedding = final_embeddings[i].tolist()\n",
    "    forge.update(resource)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lrde1uHplpxE"
   },
   "source": [
    "### Create an ElasticSearchView\n",
    "\n",
    "The goal here is to create an [Elasticsearch](https://www.elastic.co/elasticsearch/) index within the configured Nexus project in which to store and query the embeddings. Such index can be created using an [ElasticSearchView](https://bluebrainnexus.io/docs/delta/api/views/elasticsearch-view-api.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "VIEW_ID = f\"https://bbp.epfl.ch/neurosciencegraph/data/views/es/embedding_view_{int(time.time())}\"\n",
    "DIM = final_embeddings[0].shape[0]  # dimensionality of vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "G2lb5FejlpxH"
   },
   "outputs": [],
   "source": [
    "type_to_index = [\n",
    "    \"https://neuroshapes.org/NeuronMorphology\",\n",
    "    \"https://neuroshapes.org/Trace\"\n",
    "]\n",
    "view_data = {\n",
    "    \"@type\": [\n",
    "        \"ElasticSearchView\"\n",
    "    ],\n",
    "    \"includeMetadata\": True,\n",
    "    \"includeDeprecated\": False,\n",
    "    \"resourceTypes\": type_to_index,\n",
    "    \"mapping\": {\n",
    "        \"properties\": {\n",
    "            \"@id\": {\n",
    "                \"type\": \"keyword\"\n",
    "            },\n",
    "            \"@type\": {\n",
    "                \"type\": \"keyword\"\n",
    "            },\n",
    "            \"embedding\": {\n",
    "                \"type\":\"dense_vector\",\n",
    "                \"dims\": DIM\n",
    "            }\n",
    "        }\n",
    "    },\n",
    "    \"sourceAsText\": False\n",
    "}\n",
    "\n",
    "try:\n",
    "    response = nexus.views.create_(\n",
    "        org_label=ORG, project_label=PROJECT,\n",
    "        payload=view_data, view_id=VIEW_ID)\n",
    "except nexus.HTTPError as ne:\n",
    "    print(ne.response.json())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "## Recommend similar neuron morphologies and electrophysiology recordings using the embeddings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Configure forge to point to the newly created ElasticSearch view"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "forge._store.service.elastic_endpoint[\"endpoint\"] = \"/\".join(\n",
    "    (ENDPOINT, \"views\", quote_plus(ORG), quote_plus(PROJECT), quote_plus(VIEW_ID), \"_search\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_similar_resources(item_id, q=\"*\", number_of_results=10):\n",
    "    \"\"\"Get similar resources.\n",
    "    \n",
    "    Given a resource id, execute the recommendation function score query \n",
    "    to find similar resources, ranked by cosine similarity.\n",
    "    \"\"\"\n",
    "    # Get the item from Nexus and retrieve its embedding\n",
    "    item_source = forge.retrieve(id=item_id)\n",
    "    \n",
    "    # extract the embedding\n",
    "    item_embedding = item_source.embedding\n",
    "\n",
    "    query = f\"\"\"{{\n",
    "          \"query\": {{\n",
    "            \"script_score\": {{\n",
    "              \"query\": {{\n",
    "                    \"exists\": {{\n",
    "                        \"field\": \"embedding\"\n",
    "                    }}\n",
    "              }},\n",
    "              \"script\": {{\n",
    "                \"source\": \"cosineSimilarity(params.query_vector, 'embedding') + 1.0\",\n",
    "                \"params\": {{\n",
    "                  \"query_vector\": {item_embedding}\n",
    "                }}\n",
    "              }}\n",
    "            }}\n",
    "          }}\n",
    "        }}\"\"\"\n",
    "\n",
    "    results = forge.elastic(query=query, debug=False, limit=number_of_results)\n",
    "    scores = [r._score for r in results if hasattr(r, \"_score\")]\n",
    "    return [forge.from_json(dict(r._source)) for r in results if hasattr(r, \"_source\")], scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Select a morphology id to recommend similar morphologies for."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "morphology_id = morphologies_df.id[0]\n",
    "morphology_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "morphologies_df[morphologies_df[\"id\"] == morphology_id]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Important__: Elasticsearch indexing takes a few seconds, if you run the following cells and get no results, most probably the indexing has not finalized yet. Try rerunning in a few seconds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_results = 10\n",
    "forge._debug = True\n",
    "res, scores = get_similar_resources(\n",
    "    item_id=morphology_id, \n",
    "    number_of_results=number_of_results)\n",
    "\n",
    "reshaped_res = forge.reshape(res, keep=property_to_display)\n",
    "\n",
    "print(f\"Found {len(res)} Datasets\")\n",
    "result_df = forge.as_dataframe(reshaped_res)\n",
    "result_df.insert(0, \"score\", scores)\n",
    "result_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Select an electrophysiology recording id to recommend similar electrophysiology recordings for."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ephys_id = ephys_df.id[0]\n",
    "ephys_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_results = 10\n",
    "forge._debug= True\n",
    "res, scores = get_similar_resources(\n",
    "    item_id=ephys_id,\n",
    "    number_of_results=number_of_results)\n",
    "\n",
    "reshaped_res = forge.reshape(res, keep = property_to_display)\n",
    "\n",
    "print(f\"Found {len(res)} Datasets\")\n",
    "result_df = forge.as_dataframe(reshaped_res)\n",
    "result_df.insert(0, \"score\", scores)\n",
    "result_df"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Copy of Building a Content-based Recommender System using Blue Brain Nexus.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python (20210819)",
   "language": "python",
   "name": "20210819"
  },
  "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.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}