{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# PART 3 - Metadata Knowledge Graph creation in Amazon Neptune.\n",
"\n",
"Amazon Neptune is a fast, reliable, fully managed graph database service that makes it easy to build and run applications that work with highly connected datasets. The core of Neptune is a purpose-built, high-performance graph database engine. This engine is optimized for storing billions of relationships and querying the graph with milliseconds latency. Neptune supports the popular graph query languages Apache TinkerPop Gremlin and W3C’s SPARQL, enabling you to build queries that efficiently navigate highly connected datasets.\n",
"\n",
"https://docs.aws.amazon.com/neptune/latest/userguide/feature-overview.html\n",
"\n",
"In that section we're going to use TinkerPop Gremlin as the language to create and query our graph."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Important\n",
"We need to downgrade the tornado library for the gremlin libraries to work in our notebook.\n",
"\n",
"Without doing this, you'll most likely run into the following error when executing some gremlin queries: \n",
"\"RuntimeError: Cannot run the event loop while another loop is running\""
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Looking in indexes: https://pypi.org/simple, https://pip.repos.neuron.amazonaws.com\n",
"Requirement already satisfied: tornado==4.5.3 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (4.5.3)\n"
]
}
],
"source": [
"!pip install --upgrade tornado==4.5.3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Restart your kernel\n",
"Because the notebook itself has some dependencies with the tornado library, we need to restart the kernel before proceeding.\n",
"\n",
"To do so, go to the top menu > Kernel > Restart Kernel.. > Restart\n",
"\n",
"Then proceed and execute the following cells."
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Looking in indexes: https://pypi.org/simple, https://pip.repos.neuron.amazonaws.com\n",
"Requirement already satisfied: pandas in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (1.1.5)\n",
"Requirement already satisfied: python-dateutil>=2.7.3 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from pandas) (2.8.2)\n",
"Requirement already satisfied: pytz>=2017.2 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from pandas) (2021.3)\n",
"Requirement already satisfied: numpy>=1.15.4 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from pandas) (1.19.5)\n",
"Requirement already satisfied: six>=1.5 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from python-dateutil>=2.7.3->pandas) (1.16.0)\n",
"Looking in indexes: https://pypi.org/simple, https://pip.repos.neuron.amazonaws.com\n",
"Requirement already satisfied: jsonlines in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (2.0.0)\n",
"Looking in indexes: https://pypi.org/simple, https://pip.repos.neuron.amazonaws.com\n",
"Requirement already satisfied: gremlinpython in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (3.5.1)\n",
"Requirement already satisfied: isodate<1.0.0,>=0.6.0 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from gremlinpython) (0.6.0)\n",
"Requirement already satisfied: aiohttp<=3.7.4,>=3.7.0 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from gremlinpython) (3.7.4)\n",
"Requirement already satisfied: nest-asyncio in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from gremlinpython) (1.4.3)\n",
"Requirement already satisfied: aenum<3.0.0,>=1.4.5 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from gremlinpython) (2.2.6)\n",
"Requirement already satisfied: six<2.0.0,>=1.10.0 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from gremlinpython) (1.16.0)\n",
"Requirement already satisfied: yarl<2.0,>=1.0 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from aiohttp<=3.7.4,>=3.7.0->gremlinpython) (1.6.3)\n",
"Requirement already satisfied: typing-extensions>=3.6.5 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from aiohttp<=3.7.4,>=3.7.0->gremlinpython) (3.10.0.2)\n",
"Requirement already satisfied: chardet<4.0,>=2.0 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from aiohttp<=3.7.4,>=3.7.0->gremlinpython) (3.0.4)\n",
"Requirement already satisfied: idna-ssl>=1.0 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from aiohttp<=3.7.4,>=3.7.0->gremlinpython) (1.1.0)\n",
"Requirement already satisfied: multidict<7.0,>=4.5 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from aiohttp<=3.7.4,>=3.7.0->gremlinpython) (5.1.0)\n",
"Requirement already satisfied: async-timeout<4.0,>=3.0 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from aiohttp<=3.7.4,>=3.7.0->gremlinpython) (3.0.1)\n",
"Requirement already satisfied: attrs>=17.3.0 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from aiohttp<=3.7.4,>=3.7.0->gremlinpython) (21.2.0)\n",
"Requirement already satisfied: idna>=2.0 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from idna-ssl>=1.0->aiohttp<=3.7.4,>=3.7.0->gremlinpython) (3.3)\n",
"Looking in indexes: https://pypi.org/simple, https://pip.repos.neuron.amazonaws.com\n",
"Requirement already satisfied: networkx in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (2.5)\n",
"Requirement already satisfied: decorator>=4.3.0 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from networkx) (4.4.2)\n",
"Looking in indexes: https://pypi.org/simple, https://pip.repos.neuron.amazonaws.com\n",
"Requirement already satisfied: matplotlib in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (3.3.4)\n",
"Requirement already satisfied: kiwisolver>=1.0.1 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from matplotlib) (1.3.1)\n",
"Requirement already satisfied: pillow>=6.2.0 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from matplotlib) (8.4.0)\n",
"Requirement already satisfied: numpy>=1.15 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from matplotlib) (1.19.5)\n",
"Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.3 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from matplotlib) (2.4.7)\n",
"Requirement already satisfied: cycler>=0.10 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from matplotlib) (0.10.0)\n",
"Requirement already satisfied: python-dateutil>=2.1 in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from matplotlib) (2.8.2)\n",
"Requirement already satisfied: six in /home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages (from cycler>=0.10->matplotlib) (1.16.0)\n"
]
}
],
"source": [
"!pip install pandas\n",
"!pip install jsonlines\n",
"!pip install gremlinpython\n",
"!pip install networkx\n",
"!pip install matplotlib"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [],
"source": [
"import os\n",
"import jsonlines\n",
"import networkx as nx\n",
"import matplotlib.pyplot as plt\n",
"import pandas as pd"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [],
"source": [
"#load stored variable from previous notebooks\n",
"%store -r"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Loading the Gremlin libraries and connecting to our Neptune instance"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [],
"source": [
"from gremlin_python import statics\n",
"from gremlin_python.process.anonymous_traversal import traversal\n",
"from gremlin_python.process.graph_traversal import __\n",
"from gremlin_python.process.strategies import *\n",
"from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection\n",
"from gremlin_python.process.traversal import T\n",
"from gremlin_python.process.traversal import Order\n",
"from gremlin_python.process.traversal import Cardinality\n",
"from gremlin_python.process.traversal import Column\n",
"from gremlin_python.process.traversal import Direction\n",
"from gremlin_python.process.traversal import Operator\n",
"from gremlin_python.process.traversal import P\n",
"from gremlin_python.process.traversal import Pop\n",
"from gremlin_python.process.traversal import Scope\n",
"from gremlin_python.process.traversal import Barrier\n",
"from gremlin_python.process.traversal import Bindings\n",
"from gremlin_python.process.traversal import WithOptions\n",
"from gremlin_python.structure.graph import Graph\n",
"\n",
"graph = Graph()\n",
"\n",
"def start_remote_connection_neptune():\n",
" remoteConn = DriverRemoteConnection(your_neptune_endpoint_url,'g')\n",
" g = graph.traversal().withRemote(remoteConn)\n",
" return g\n",
"\n",
"# g is the traversal source to use to query the graph \n",
"g = start_remote_connection_neptune()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"IMPORTANT:\n",
"- Note that the remote connection will time out after few minutes if unused so if you're encountering exceptions after having paused the notebook execution for a while, please re-run the above cell.\n",
"- Make sure your Neptune DB is created for the sole purpose of this labs as we'll be cleaning it before starting."
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[['V'], ['drop'], ['none'], ['values', '_ipython_canary_method_should_not_exist_'], ['values', '_ipython_canary_method_should_not_exist_']]"
]
},
"execution_count": 47,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#CAREFUL - the below line of code empties your graph. Again, make sure you're using a dedicated instance for this workshop\n",
"g.V().drop().iterate()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## A note on Gremlin\n",
"\n",
"Gremlin is a functional, data-flow language that enables users to succinctly express complex traversals on (or queries of) their application's property graph. Every Gremlin traversal is composed of a sequence of (potentially nested) steps. A step performs an atomic operation on the data stream. Every step is either a map-step (transforming the objects in the stream), a filter-step (removing objects from the stream), or a sideEffect-step (computing statistics about the stream).\n",
"\n",
"More info here: https://tinkerpop.apache.org/gremlin.html"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The image below is an extract from:\n",
"https://tinkerpop.apache.org/docs/3.5.1/tutorials/getting-started/#_the_next_fifteen_minutes\n",
"\n",
"I highly recommend you to be familiar with the concepts of Vertex and Edges at the very minimum before proceeding with the notebook."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"![Gremlin vertex edge](../static/gremlin-vertex-edge.png \"Gremlin vertex edge\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Vertices and Edges names\n",
"\n",
"See below the variables containing the labels for our vertices and edges that we'll create across the notebook."
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {},
"outputs": [],
"source": [
"#Vertex representing a Video\n",
"V_VIDEO = \"video\"\n",
"\n",
"#Vertex representing a \"scene\" e.g. SHOT, TECHNICAL_CUE\n",
"V_VIDEO_SCENE = \"video_scene\"\n",
"\n",
"#Vertex representing a Video segment. we arbitrary split our video into 1min segments and attach metadata to the segments itselves\n",
"V_VIDEO_SEGMENT = 'video_segment'\n",
"\n",
"#Edge between VIDEO and SEGMENT\n",
"E_HAS_SEGMENT = 'contains_segment'\n",
"\n",
"#Edge between VIDEO and SCENE\n",
"E_HAS_SCENE = 'contains_scene'\n",
"\n",
"#Edge between Scene and Segment\n",
"E_BELONG_TO_SEGMENT = 'belong_to_segment'\n",
"\n",
"#Vertex representing a label extracted by Rekognition from the video\n",
"V_LABEL = 'label'\n",
"\n",
"#Edge between SEGMENT and LABEL\n",
"E_HAS_LABEL = 'has_label'\n",
"\n",
"#Edge between parent LABEL and child LABEL e.g. construction -> bulldozer\n",
"E_HAS_CHILD_LABEL = 'has_child_label'\n",
"\n",
"#Vertex representing the NER\n",
"V_ENTITY = 'entities'\n",
"\n",
"#Vertex representing the type of NER\n",
"V_ENTITY_TYPE = 'entity_type'\n",
"\n",
"#Edge between ENTITY and ENTITY_TYPE\n",
"E_IS_OF_ENTITY_TYPE = 'is_of_entity_type'\n",
"\n",
"#Edge between SEGMENT and ENTITY\n",
"E_HAS_ENTITY = 'has_entity'\n",
"\n",
"#Vertex representing a TOPIC\n",
"V_TOPIC = 'topic'\n",
"\n",
"#Vertex representing a TOPIC_TERM\n",
"V_TOPIC_TERM = 'topic_term'\n",
"\n",
"#Edge between a VIDEO_SEGMENT and a TOPIC\n",
"E_HAS_TOPIC = 'has_topic'\n",
"\n",
"#Edge between a TOPIC and a TOPIC_TERM\n",
"E_HAS_TERM = 'has_term'\n",
"\n",
"#Vertex representing a TERM\n",
"V_TERM = 'term'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## We start by adding our video to the Graph\n",
"\n",
"Note how I start with g, our traversal graph, then call the addV (V for Vertex) method and then attach properties to the new vertex. I end the line with \".next()\" which will return the newly created node (similar to how an iterator would work). all method are \"chained\" together in one expression."
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {},
"outputs": [],
"source": [
"sample_video_vertex = g.addV(V_VIDEO).property(\"name\", video_name).property(\"filename\", video_file) .property('description', 'description of the video').next() "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[QUERY] We're listing all the vertices in the graph with their metadata. At this stage, we only have one.\n",
"\n",
"Explanation: g.V() gets us all vertices in the graph, the .hasLabel() filters the vertices based on the vertex label(=type), the .valueMap() returns all properties for all vertices and the .toList() returns the full list. Note that you can use .next() instead of toList() to just return the next element in the list."
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[{'name': ['video_trailer_4min'],\n",
" 'description': ['description of the video'],\n",
" 'filename': ['video_trailer_4min.mp4']}]"
]
},
"execution_count": 50,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g.V().hasLabel(V_VIDEO).valueMap().toList()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[QUERY] Below is a different way to precisely return a vertex based on its name. \n",
"\n",
"Explanation: g.V() gives us all the vertices, .has() allows us to filter based on the name of the vertex and .next() returns the first (and only) item from the iterator. note that we haven't used .valueMap() so what is returned is the ID of the vertex."
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"v[8ebeae02-b1cc-e87e-5433-248ead2b8b23]"
]
},
"execution_count": 51,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g.V().has('name', video_name).next()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Creating 1min segments vertices in Neptune \n",
"As mentioned in the previous notebook, we are creating metadata segments that we'll use to store labels and other information related to those 1min video segments. \n",
"This will give us a more fine grained view of the video's topics and metadata."
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"60000\n"
]
}
],
"source": [
"print(segment_size_ms)"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {},
"outputs": [],
"source": [
"#get the video duration by looking at the end of the last segment.\n",
"def get_video_duration_in_ms(segment_detection_output):\n",
" return segment_detection_output['Segments'][-1]['EndTimestampMillis']\n",
"\n",
"#create a new segment vertex and connect it to the video\n",
"def add_segment_vertex(video_name, start, end, g):\n",
" #retrieving the video vertex\n",
" video_vertex = g.V().has(V_VIDEO, 'name', video_name).next()\n",
"\n",
" #generating a segment ID\n",
" segment_id = video_name + '-' + str(start) + '-' + str(end)\n",
" \n",
" #creating a new vertex for the segment\n",
" new_segment_vert = g.addV(V_VIDEO_SEGMENT).property(\"name\", segment_id).property('StartTimestampMillis', start).property('EndTimestampMillis', end).next()\n",
"\n",
" #connecting the video vertex to the segment vertex\n",
" g.V(video_vertex).addE(E_HAS_SEGMENT).to(new_segment_vert).iterate()\n",
"\n",
"#generate segment vertices of a specific duration (default 60s) for a specific video\n",
"def generate_segment_vertices(video_name, g, duration_in_millisecs, segment_size_in_millisecs=60000):\n",
" #retrieve the mod\n",
" modulo = duration_in_millisecs % segment_size_in_millisecs\n",
"\n",
" #counter that we'll increment by segment_size_in_millisecs steps\n",
" counter = 0\n",
" \n",
" while ((counter + segment_size_in_millisecs) < duration_in_millisecs) : \n",
" start = counter\n",
" end = counter + segment_size_in_millisecs\n",
"\n",
" add_segment_vertex(video_name, start, end, g)\n",
" \n",
" counter += segment_size_in_millisecs\n",
" \n",
" #adding the segment vertex to the video vertex\n",
" add_segment_vertex(video_name, duration_in_millisecs - modulo, duration_in_millisecs, g) \n",
" \n",
"#add a vertex if it doesn't already exist\n",
"def add_vertex(vertex_label, vertex_name, g): \n",
" g.V().has(vertex_label,'name', vertex_name).fold().coalesce(__.unfold(), __.addV(vertex_label).property('name',vertex_name)).iterate()\n",
" \n",
"#add an edge between 2 vertices\n",
"def add_edge(vertex_label_from, vertex_label_to, vertex_name_from, vertex_name_to, edge_name, g, weight=None):\n",
" if weight == None:\n",
" g.V().has(vertex_label_to, 'name', vertex_name_to).as_('v1').V().has(vertex_label_from, 'name', vertex_name_from).coalesce(__.outE(edge_name).where(__.inV().as_('v1')), __.addE(edge_name).to('v1')).iterate()\n",
" else:\n",
" g.V().has(vertex_label_to, 'name', vertex_name_to).as_('v1').V().has(vertex_label_from, 'name', vertex_name_from).coalesce(__.outE(edge_name).where(__.inV().as_('v1')), __.addE(edge_name).property('weight', weight).to('v1')).iterate()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note: remember, the SegmentDetectionOutput object contains the output of the Amazon Rekognition segment (=scene) detection job"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {},
"outputs": [],
"source": [
"duration = get_video_duration_in_ms(SegmentDetectionOutput)\n",
"generate_segment_vertices(video_name, g, duration, segment_size_ms)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[QUERY] Let's retrieve the segments that are connected to the video vertex via an edge, ordered by StartTimestampMillis. In that case we limit the result set to 5 items.\n",
"\n",
"Explanation: g.V() get us all vertices, .has(V_VIDEO, 'name', video_name) filters on the video vertices with name=video_name, .out() gives us all vertices connected to this vertex by an outgoing edge, .hasLabel(V_VIDEO_SEGMENT) filters the vertices to video segments only, .order().by() orders the vertices by StartTimestampMillis, .valueMap() gives us all properties for those vertices, .limit(5) reduces the results to 5 items, .toList() gives us the list of items."
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[{'name': ['video_trailer_4min-0-60000'],\n",
" 'StartTimestampMillis': [0],\n",
" 'EndTimestampMillis': [60000]},\n",
" {'name': ['video_trailer_4min-60000-120000'],\n",
" 'StartTimestampMillis': [60000],\n",
" 'EndTimestampMillis': [120000]},\n",
" {'name': ['video_trailer_4min-120000-180000'],\n",
" 'StartTimestampMillis': [120000],\n",
" 'EndTimestampMillis': [180000]},\n",
" {'name': ['video_trailer_4min-180000-240000'],\n",
" 'StartTimestampMillis': [180000],\n",
" 'EndTimestampMillis': [240000]},\n",
" {'name': ['video_trailer_4min-240000-277944'],\n",
" 'StartTimestampMillis': [240000],\n",
" 'EndTimestampMillis': [277944]}]"
]
},
"execution_count": 55,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list_of_segments = g.V().has(V_VIDEO, 'name', video_name).out().hasLabel(V_VIDEO_SEGMENT) \\\n",
" .order().by('StartTimestampMillis', Order.asc).valueMap().limit(5).toList()\n",
"\n",
"list_of_segments"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Graph Visualisation\n",
"The networkx library alongside with matplotlib allows us to draw visually the graph.\n",
"\n",
"Let's draw our vertex video and the 1min segments we just created."
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {},
"outputs": [],
"source": [
"#Function printing the graph from a start vertex and a list of edges that will be traversed/displayed.\n",
"def print_graph(start_vertex_label, start_vertex_name, list_edges, displayLabels=True, node_size=2000, node_limit=200):\n",
"\n",
" #getting the paths between vertices\n",
" paths = g.V().has(start_vertex_label, 'name', start_vertex_name)\n",
" \n",
" #adding the edges that we want to traverse\n",
" for edge in list_edges:\n",
" paths = paths.out(edge)\n",
" paths = paths.path().toList()\n",
" \n",
" #creating graph object\n",
" G=nx.DiGraph() \n",
" \n",
" #counters to limit the number of nodes being displayed.\n",
" limit_nodes_counter = 0\n",
"\n",
" #creating the graph by iterating over the paths\n",
" for p in paths:\n",
" #depth of the graph\n",
" depth = len(p)\n",
" \n",
" #we build our graph\n",
" for i in range(0, depth -1):\n",
" label1 = g.V(p[i]).valueMap().next()['name'][0]\n",
" label2 = g.V(p[i+1]).valueMap().next()['name'][0]\n",
"\n",
" if limit_nodes_counter < node_limit:\n",
" G.add_edge(label1, label2)\n",
" limit_nodes_counter += 1\n",
" \n",
" plt.figure(figsize=(12,7))\n",
" nx.draw(G, node_size=node_size, with_labels=displayLabels)\n",
" plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"#please note that we limit the number of nodes being displayed\n",
"print_graph(V_VIDEO, video_name, [E_HAS_SEGMENT], node_limit=15)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Add the scenes into our graph\n",
"\n",
"In the below steps we're connecting the scenes to the video itself and not the segments as we want to be able to search and list the different types of scenes at the video level. However, note that we're not going to attach any specific metadata at the scene level, only at the segment level."
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {},
"outputs": [],
"source": [
"def store_video_segment(original_video_name, json_segment_detection_output, orig_video_vertex):\n",
" \n",
" shot_counter = 0\n",
" tech_cue_counter = 0\n",
" \n",
" for technicalCue in json_segment_detection_output['Segments']:\n",
" #start\n",
" frameStartValue = technicalCue['StartTimestampMillis'] / 1000\n",
" #end\n",
" frameEndValue = technicalCue['EndTimestampMillis'] / 1000\n",
" \n",
" #SHOT or TECHNICAL_CUE\n",
" segment_type = technicalCue['Type']\n",
" \n",
" counter = -1\n",
" if (segment_type == 'SHOT'):\n",
" shot_counter += 1\n",
" counter = shot_counter\n",
" elif (segment_type == 'TECHNICAL_CUE'):\n",
" tech_cue_counter += 1\n",
" counter = tech_cue_counter\n",
"\n",
" segment_id = original_video_name + '-' + segment_type + '-' + str(counter)\n",
" \n",
" #creating the vertex for the video segment with all the metadata extracted from the segment generation job\n",
" new_vert = g.addV(V_VIDEO_SCENE).property(\"name\", segment_id).property(\"type\", segment_type) \\\n",
" .property('StartTimestampMillis', technicalCue['StartTimestampMillis']).property('EndTimestampMillis', technicalCue['EndTimestampMillis']) \\\n",
" .property('StartFrameNumber', technicalCue['StartFrameNumber']).property('EndFrameNumber', technicalCue['EndFrameNumber']) \\\n",
" .property('DurationFrames', technicalCue['DurationFrames']).next()\n",
" \n",
" #creating the edge between the original video vertex and the segment vertex with the type as a property of the relationship\n",
" g.V(orig_video_vertex).addE(E_HAS_SCENE).to(new_vert).properties(\"type\", segment_type).iterate()"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {},
"outputs": [],
"source": [
"store_video_segment(video_name, SegmentDetectionOutput, sample_video_vertex)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[QUERY] We're retrieving the list of edges/branches created between the video and the scenes.\n",
"\n",
"\n",
"Explanation: g.V() returns all vertices, .has(V_VIDEO, 'name', video_name) returns the V_VIDEO vertex with name=video_name, .out(E_HAS_SCENE) returns the list of vertices that are connected to the V_VIDEO vertex by a E_HAS_SCENE edge, toList() returns the list of items."
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"the sample video vertex has now 133 edges connecting to the scenes vertices\n"
]
}
],
"source": [
"list_of_edges = g.V().has(V_VIDEO, 'name', video_name).out(E_HAS_SCENE).toList()\n",
"print(f\"the sample video vertex has now {len(list_of_edges)} edges connecting to the scenes vertices\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[QUERY] Let's search for the technical cues (black and fix screens) at the end of the video.\n",
"\n",
"Explanation: g.V() returns all vertices, .has(V_VIDEO, 'name', video_name) returns the V_VIDEO vertex with name=video_name, .out(E_HAS_SCENE) returns the list of vertices that are connected to the V_VIDEO vertex by a E_HAS_SCENE edge, .has('type', 'TECHNICAL_CUE') filters the list on type=TECHNICAL_CUE, the rest was seen above already."
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[{'StartFrameNumber': [0],\n",
" 'DurationFrames': [6664],\n",
" 'name': ['video_trailer_4min-TECHNICAL_CUE-1'],\n",
" 'StartTimestampMillis': [0],\n",
" 'EndTimestampMillis': [277944],\n",
" 'type': ['TECHNICAL_CUE'],\n",
" 'EndFrameNumber': [6664]},\n",
" {'StartFrameNumber': [6062],\n",
" 'DurationFrames': [234],\n",
" 'name': ['video_trailer_4min-TECHNICAL_CUE-3'],\n",
" 'StartTimestampMillis': [252835],\n",
" 'EndTimestampMillis': [262595],\n",
" 'type': ['TECHNICAL_CUE'],\n",
" 'EndFrameNumber': [6296]},\n",
" {'StartFrameNumber': [527],\n",
" 'DurationFrames': [118],\n",
" 'name': ['video_trailer_4min-TECHNICAL_CUE-2'],\n",
" 'StartTimestampMillis': [21980],\n",
" 'EndTimestampMillis': [26901],\n",
" 'type': ['TECHNICAL_CUE'],\n",
" 'EndFrameNumber': [645]}]"
]
},
"execution_count": 61,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g.V().has(V_VIDEO, 'name', video_name).out(E_HAS_SCENE) \\\n",
" .has('type', 'TECHNICAL_CUE') \\\n",
" .order().by('EndTimestampMillis', Order.desc) \\\n",
" .limit(5).valueMap().toList() "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"Let's print the graph for those newly created SCENE vertices"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"#please note that we limit the number of nodes being displayed\n",
"print_graph(V_VIDEO, video_name, [E_HAS_SCENE], node_limit=15)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Create the labels vertices and link them to the segments\n",
"We're now going to create vertices to represent the labels in our graph and connect them to the 1min segments"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {},
"outputs": [],
"source": [
"def create_label_vertices(LabelDetectionOutput, video_name, g, confidence_threshold=80):\n",
"\n",
" labels = LabelDetectionOutput['Labels']\n",
" \n",
" for instance in labels:\n",
" #keeping only the labels with high confidence\n",
" label_details_obj = instance['Label']\n",
" confidence = label_details_obj['Confidence']\n",
" if confidence > confidence_threshold:\n",
" \n",
" #adding then main label name to the list\n",
" label_name = str(label_details_obj['Name']).lower()\n",
" \n",
" #adding the label vertex\n",
" add_vertex(V_LABEL, label_name, g)\n",
"\n",
" #adding the link between video and label\n",
" add_edge(V_VIDEO, V_LABEL, video_name, label_name, E_HAS_LABEL, g, weight=None)\n",
" \n",
" \n",
" #adding parent labels too\n",
" parents = label_details_obj['Parents']\n",
" if len(parents) > 0:\n",
" for parent in parents:\n",
" #create parent vertex if it doesn't exist\n",
" parent_label_name = str(parent['Name']).lower()\n",
" add_vertex(V_LABEL, parent_label_name, g)\n",
" \n",
" #create the relationship between parent and children if it doesn't already exist\n",
" add_edge(V_LABEL, V_LABEL, parent_label_name, label_name, E_HAS_CHILD_LABEL, g, weight=None)\n",
" "
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {},
"outputs": [],
"source": [
"create_label_vertices(LabelDetectionOutput, video_name, g, 80)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[QUERY] Let's list the labels vertices to see what was created above.\n",
"\n",
"Explanation: g.V() returns all vertices, .hasLabel(V_LABEL) returns only the vertices of label/type V_LABEL, .valueMap().limit(20).toList() gives us the list with properties for the first 20 items."
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[{'name': ['apparel']},\n",
" {'name': ['human']},\n",
" {'name': ['plant']},\n",
" {'name': ['outdoors']},\n",
" {'name': ['shorts']},\n",
" {'name': ['accessories']},\n",
" {'name': ['face']},\n",
" {'name': ['glasses']},\n",
" {'name': ['shirt']},\n",
" {'name': ['tie']},\n",
" {'name': ['blonde']},\n",
" {'name': ['girl']},\n",
" {'name': ['teen']},\n",
" {'name': ['halo']},\n",
" {'name': ['nature']},\n",
" {'name': ['interior design']},\n",
" {'name': ['sash']},\n",
" {'name': ['symbol']},\n",
" {'name': ['trademark']},\n",
" {'name': ['text']}]"
]
},
"execution_count": 65,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#retrieving a list of the first 20 labels\n",
"label_list = g.V().hasLabel(V_LABEL).valueMap().limit(20).toList()\n",
"label_list"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's display a graph with our video's labels and the child labels relationships in between labels."
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"print_graph(V_VIDEO, video_name, [E_HAS_LABEL, E_HAS_CHILD_LABEL], node_limit=15)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[QUERY] A typical query would be to search for videos who have a specific label.\n",
"\n",
"Explanation: g.V().has(V_LABEL, 'name', ..) returns the first label vertex from the previous computed list, .in_(E_HAS_LABEL) returns all vertices who have an incoming edge (inE) pointing to this label vertex, .valueMap().toList() returns the list with properties. \n",
"\n",
"note that in_(E_HAS_LABEL) is equivalent to .inE(E_HAS_LABEL).outV() where .inE(E_HAS_LABEL) returns all incoming edges with the specified label and .outV() will traverse to the vertices attached to that edge.\n",
"\n",
"Obviously we only have the one result as we've only processed one video so far."
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[{'name': ['video_trailer_4min'],\n",
" 'description': ['description of the video'],\n",
" 'filename': ['video_trailer_4min.mp4']}]"
]
},
"execution_count": 67,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g.V().has(V_LABEL, 'name', label_list[0]['name'][0]).in_(E_HAS_LABEL).valueMap().toList()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Create the topics and associated topic terms vertices\n",
"We are going to re-arrange a bit the raw results from the topic modeling job to make it more readable"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"