Graph Analytics

Graphs are used to model a large number of real-world scenarios, including professional networks, flight networks, and schedules. Working in these problem domains involves a deep understanding of how graphs are represented and how graph algorithms work. Learn the basic components of a graph and how nodes and edges can be used to model relationships. Examine how domains such as social networks, purchases on an e-commerce platform, and connected devices can be modeled using graphs. Next, explore how to use an organizing principle to add semantic meaning and context to graphs. Discover how to apply higher-level organizing principles to knowledge graphs using taxonomies and ontologies. Finally, get hands-on experience creating and manipulating graphs, and running graph algorithms using the NetworkX library in Python. When you have completed this course, you will have a solid understanding of how graphs model entities and relationships in the real world.

In order to really understand how graphs work, it is important to know how they are implemented. There are multiple ways to represent graphs in code and each representation has its own advantages and disadvantages. In this course, you will implement graphs using three different representations - the adjacency matrix, the adjacency list, and the adjacency set. Learn how the adjacency matrix representation uses a square matrix to represent connections between the nodes of a graph and also edge weights. Next, explore how the adjacency list suffers from a major drawback: the same graph can have multiple representations. Finally, discover how the adjacency set representation has exactly one way in which a graph is represented. When you are finished with this course, you will be able to create and work with your own graph structures and optimize them for different purposes.

What makes the graph data structure very interesting and powerful is the large number of algorithms that can be run on graphs to extract insights. Common graph algorithms include traversing a graph and computing the shortest path between nodes. Implementing these algorithms is a great way to learn how graphs are explored and optimized. In this course, learn how graphs can be traversed by studying both depth-first and breadth-first graph traversal and discover how they can be implemented using a stack and a queue respectively. Next, explore how to compute the shortest path in an unweighted graph. And finally, use Dijkstra's algorithm to compute the shortest path in a weighted graph. Upon completion of this course, you will be able to implement optimal algorithms on graphs.

This course serves as a quick introduction to the concepts around graph databases, their use cases, and gives you a glimpse into the Neo4j graph database. Explore a theoretical overview of graphs, including how information is stored as nodes and edges, and how graph databases emphasize the connections between entities. Learn about a specific graph database, Neo4j, which is among the most mature and widely used out in the market. Practice the installation and setup of such a database, and look into the UI-based applications available to interact with it - namely the Neo4j Desktop and Neo4j browser. Moving on, examine some basic database administration tasks such as creating a local database and connecting to a remotely hosted one. Finally, delve into the fundamentals of querying a Neo4j database using its own Cypher query language. Upon completion you'll be able to recognize the strengths and use cases for graph databases and to set up and use Neo4j Desktop

Understanding the fundamental administration tasks for a Neo4j database is useful for administrators learning about this graph DB as well as developers who use it in their own environments. Begin by learning the very basics of setting up a graph database - creating a project which serves as a logical grouping of database management systems (DBMS). Create locally stored database systems and discover how to connect to a remotely hosted one using Neo4j Desktop. Moving on, use the Cypher shell to interact with a Neo4j database and use this to manage a database system and perform tasks such as taking a database offline, creating parameters for queries, and running Cypher queries. Finally, learn how to modify the configuration file for a Neo4j database management system, where you explore options such as limiting the number of databases in a DBMS and also modifying the HTTP connection settings. Upon completion, you'll be able to use the Neo4j Desktop, Neo4j Browser, and the Cypher shell to perform key database administration tasks.

Knowing how to perform a variety of database management tasks from the Neo4j Browser allows database administrators to make best use of the available features and to maximize productivity. Begin with learning about the fundamental administration tasks of creating a new user with a specific set of permissions on a database system and testing that user's permissions. Discover the various built-in roles available for a Neo4j user and how to manage a user during their lifecycle. Moving on, explore the different ways in which query results can be viewed, from a graph view where the nodes and relationships are clearly visible, to a tabular and plain text view of the data. Finally, test out the Neo4j API by submitting an HTTP POST request to initialize a transaction for the creation of a node, and then commit that transaction. By completing this course, you'll explore the various granular details which can be configured in the Neo4j Browser to customize it for your own requirements.

This first course in the path delves into the basics of the Cypher query language. You will learn about the creation of nodes, relationships between nodes, and how to search for simple patterns among them. Begin with a simple query with a CREATE clause in order to create a node. Build upon your query at each step, starting with an empty node, then creating nodes with properties and nodes containing one or more labels. You then move on to setting relationships between nodes. Define relationships between existing nodes in the database, and build nodes containing their own properties. All the while, gaining familiarity with the syntax of CREATE queries in the Cypher query language, how directions are set when defining relationships, and the rules and conventions around names for node labels and relationships. After completion of this course you'll know how to create nodes and relationships between nodes in a Neo4j database using the Cypher query language.

This course introduces you to the breadth of operations which can be performed using the Cypher query language to add, modify, and delete nodes and relationships. Kick things off with queries that create multiple nodes and relationships in a single operation. Move on to MATCH queries where you search for relationships based on a variety of different patterns. Then, delve into the OPTIONAL MATCH clause to search based on partial pattern matches. Next, discover how to update operations where node properties are created, changed, or removed. Explore the MERGE clause in the Cypher language. This clause is similar to the CREATE clause but has a few notable differences that make it the better choice in many scenarios. Finally, learn how nodes and relationships in Neo4j can be removed and some of the rules around such operations. After completing this course you'll be able to add, modify, and delete nodes and relationships in a Neo4j database using the Cypher query language.

This course explores a variety of Cypher queries that go beyond simple reads and writes. The course also involves identifying complex patterns and combinations of data in nodes and relationships. Begin with a deep dive into querying for patterns in relationships. Move on to the operation of finding the shortest paths between two nodes in a graph structure. Next, explore queries based on the properties of nodes or relationships, where you will look for elements matching a single criterion as well as multiple criteria defined using logical operations. Following that, explore some of the fundamental aggregation operations which can be performed on data using the Cypher language on both text and numeric data. Finally, discover how to order query results and limit their size using the LIMIT and SKIP clauses. Upon completion, you'll know how to apply graph-specific and generic database features to analyze a Neo4j database using the Cypher language.

The Neo4j Bloom application allows those working with graphs to query graph databases sans the need to write code or a Cypher query. Use this course to learn how to use Neo4j Bloom to easily query a Neo4j graph database and achieve rich visualizations of query results. Practice loading data onto a Neo4j database from CSV files. Work with Neo4j Bloom to run simple search queries on patterns in the nodes and relationships. Moving along, explore some of the key features of the Bloom interface, including creating scenes showcasing the results of search queries and working with scenes using card lists. Learn to edit graphs using Bloom. And finally, work with the Bloom interface to find connections between nodes. Upon completion, you'll be able to use Neo4j Bloom to analyze a Neo4j database and give a rich visual representation to this analysis.

This course delves into the fundamentals of graph data modeling from a theoretical standpoint before applying some of the principles to a Neo4j database. Begin with an overview of data modeling in general and then graph modeling in particular. Learn to recognize the similarities in modeling for relational, document, and graph databases and identify how their approaches vary. Next, in the practical portion of the course, build a database with different entity types and multiple relationship types. Explore the use of properties, labels, and relationships to model your data correctly for efficient query execution. Finally, delve into translating a CSV file containing a many-to-one relationship between entity types into a graph database and discover how to translate a tabular structure like a CSV file into a graph structure for Neo4j.

This course focuses on using the Neo4j ETL tool to automate the migration from a relational database to a Neo4j graph and redefining a graph data model with the APOC library. Start by setting up a relational database with multiple tables for entities as well as relationships between entities. Discover how relationships are modeled in tabular structures and what needs to happen for their translation into graphs. Use the Neo4j ETL tool to map the relational tables to a set of nodes and relationships. You will see where the tool can save you work, and what its limitations are. Finally, learn about some of the options available in the Neo4j's APOC library to re-factor your graph data model. This will include redefining the properties in nodes as well as modeling relationships with multiple properties as nodes with simpler relationships.

The Neo4j AuraDB cloud database service enables developers creating graph applications to focus on the same and not bother about database administration. Take this course to create and load an AuraDB database and integrate it with various tools in the Neo4j ecosystem. Practice setting up a free AuraDB account and provisioning an empty Neo4j cloud database. Learn how to migrate data to the database. Then, analyze data in an AuraDB database with the web-based Neo4j Bloom application. Moving along, practice writing a Python application to query an AuraDB database. Work on connecting with and running queries on the database using Cypher Shell. Upon completion, you'll be able to work with the Neo4j AuraDB cloud tool in order to simplify database administration for graph applications.

The Graph Data Science (GDS) library provides data scientists and developers with the necessary tools to perform powerful analysis of their graph data. In this course, you will look at various use cases of GDS and cover some of its essential operations. Begin with an overview of the GDS library and then dive into using the library by building in-memory graphs from the contents of your Neo4j database. Explore how to build graphs using native and Cypher projections. Next, apply a graph algorithm to your GDS graph and see how it can be used to obtain meaningful information about the nodes and relationships in your data. After completing this course, you will have a fundamental understanding of the GDS library for Neo4j and the necessary capabilities to build your own in-memory graphs and extract significant insights.

This course will teach you to use operations that modify in-memory graphs built with the Graph Data Science (GDS) library, update the properties of the underlying database, and export their contents to a database or file. You begin with a mutate operation to add new properties to an in-memory graph. You will learn how you can save the results of graph algorithms in such graphs for later reference. Next, you explore the write operation to update the underlying database with the results of graph algorithms on in-memory graphs. You will then move on to exporting your graph to a persistent store. Finally, you cover the different ways you can remove GDS graphs from the graph catalog. While doing so, you will explore the degree centrality calculation, which measures how well-connected nodes are in a network. After completing this course, you will have a fundamental understanding of how to administer in-memory graphs using the Graph Data Science library in Neo4j.

This course will introduce you to several graph algorithms in Neo4j's Graph Data Science library and explore how you can apply these to different types of graphs. You begin by building a little social network of people connected as friends. Then you will cover the steps involved in modeling friendships as undirected relationships in an in-memory graph and applying algorithms to this social network. You will use measures of centrality to identify highly connected nodes in a network. Next, you dive into community detection algorithms to find clusters of friends in a social network. From there, you will model a network as a graph with weighted edges then apply traversal algorithms on this graph, from finding shortest paths between nodes to breadth-first and depth-first traversals. Finally, you get a glimpse into the FastRP algorithm to transform nodes in your graph to vectors with a specific number of dimensions. After completing this course, you will know how to apply various graphic algorithms to extract meaningful information from a graph.

Apache Spark, which is a widely used analytics engine, also helps anyone modeling graphs to perform powerful graph analytics. GraphFrames, a Spark package, aids this process by providing various graph algorithm implementations. Use this course to learn about GraphFrames and the application of graph algorithms on data to extract insights. Explore how GraphFrames complements the Apache Hadoop ecosystem in processing graph data. Getting hands-on, construct and visualize a GraphFrame. Practice querying nodes and relationships in a graph and finding motifs in it. Moving along, work with the breadth-first search and the shortestPaths functions to find paths between graph nodes. And finally, apply the PageRank algorithm to arrive at the most relevant nodes in a network. Upon completion, you'll be able to use GraphFrames to analyze and generate insights from graph data.

Graph neural networks (GNNs) have recently become widely applied graph-analysis tools as they help capture indirect dependencies between data elements. Take this course to learn how to transform graph data for use in GNNs. Explore the use cases for machine learning in analyzing graph data and the challenges around modeling graphs for use in neural networks, including the use of adjacency matrices and node embeddings. Examine how a convolution function captures the properties of a node and those of its neighbors. While doing so explore normalization concepts, including symmetric normalization of adjacency matrices. Moving along, work with the Spektral Python library to model a graph dataset for application in a GNN. Finally, practice defining a convolution function for a GNN and examine how the resultant message propagation works. Upon completion you'll have a clear understanding of the need for and challenges around using graph data for machine learning and recognize the power of graph convolutional networks (GCNs).

Machine learning (ML) models can be used to extract insights from your graph data. Use this course to learn how to build, train, and evaluate a multi-label classification model using a graph convolutional network (GCN) constructed using the Spektral Python library. Begin by structuring a Spektral dataset for machine learning and learn how data is modeled using an adjacency matrix and feature vectors. Explore how to assign instances of your data to training, validation, and test sets using masks applied to your dataset instance. Construct a graph neural network (GNN) with input layers for the adjacency matrix and features and a GCN convolutional layer and use it to perform node classification. Discover how node features, the edges of the graph, and the structure of the neural network affect the performance of the classification model. Upon completion, you'll be able to prepare a graph structure for use in an ML model and define the factors which can improve the accuracy of model predictions.

Final Exam: Graph Analytics will test your knowledge and application of the topics presented throughout the Skillsoft Aspire Graph Analytics Journey.