Neo4j Graph Data Science Certification exam! 题库2

Indexes Which of the following indexes are available in Neo4j? BLOOM CURRENCY TEXT RANGE VECTOR

In Neo4j, the following types of indexes are available:

• TEXT: Used for full-text search on properties of nodes and relationships.
• RANGE: This is a general-purpose index that supports range queries and is based on B-tree structures. It's the default type of index used when you create an index without specifying the type.

The other options provided are not types of indexes in Neo4j:

• BLOOM: There is no index type called "BLOOM" in Neo4j. Bloom filters are a probabilistic data structure used to test whether an element is a member of a set, but they are not a type of index in Neo4j.

• CURRENCY: There is no index type called "CURRENCY" in Neo4j.

• VECTOR : While Neo4j supports vector search through the use of the natively integrated AI and machine learning library, there is no specific "VECTOR" index type. Vector search capabilities are provided through the use of the ngraph library or other similar mechanisms, not through a "VECTOR" index type.

So, the correct indexes available in Neo4j from the options provided are TEXT and RANGE.

Unique constraints Complete the Cypher statement below to create an existence constraint on the rated property on the ()-[:RATED]→() relationship. cypher CREATE CONSTRAINT rated_rating FOR ()-[r:RATED]-() REQUIRE r.rating

To create a uniqueness constraint on the rated property of the RATED relationship, you would use the following Cypher statement:
cypher

CREATE CONSTRAINT rated_rating FOR ()-[r:RATED]-() REQUIRE r.rating IS UNIQUE

This statement ensures that the rating property on all RATED relationships in the graph is unique. If you try to create a relationship with a rating value that already exists, Neo4j will reject the operation due to the uniqueness constraint violation.
Schema visualizations Which of the following Cypher statements will visualize your database schema in Workspace or Neo4j Browser? CALL db.schema.visualization() SHOW SCHEMA MATCH schema = VISUALIZE ()-[]→() RETURN schema CALL schema.visualize()

The correct Cypher statement to visualize your database schema in Neo4j Browser (formerly known as the Neo4j Browser) is:

cypher

CALL db.schema.visualization()

This procedure call will generate a visualization of the schema, which includes nodes, relationships, indexes, and constraints, and display it in the Neo4j Browser.

The other options provided are incorrect or do not exist in Neo4j:

• SHOW SCHEMA: This is not a valid Cypher statement in Neo4j.

• MATCH schema = VISUALIZE ()-[]→() RETURN schema : This is not a valid Cypher statement. The VISUALIZE function does not exist in this form.

• CALL schema.visualize() : This is not a valid procedure call. The correct procedure is db.schema.visualization(), not schema.visualize().

Importing CSV files If you omit WITH HEADERS from a LOAD CSV statement, which of the following will happen? The statement will lead to a Syntax Error An LLM will be to generate headers for you Each row will be treated as a list The database will crash

If you omit WITH HEADERS from a LOAD CSV statement in Cypher, the following will happen:

Each row will be treated as a list

When you use LOAD CSV without the WITH HEADERS clause, Neo4j assumes that the first row of the CSV file contains data rather than column headers. Therefore, each subsequent row in the CSV file is treated as a list of values that correspond to the columns in the data.

The other options are incorrect for the following reasons:

• The statement will lead to a Syntax Error : Omitting WITH HEADERS does not cause a syntax error; it simply changes the interpretation of the CSV data.

• An LLM will be to generate headers for you : There is no such feature in Neo4j that automatically generates headers for you. The WITH HEADERS clause must be explicitly included if the first row of the CSV contains headers.

• The database will crash : Omitting WITH HEADERS is a common practice and will not cause the database to crash. It simply affects how the data is read from the CSV file.

Data types Which of the following statements applies when using the LOAD CSV statement? Select all of the options below that apply. The database will automatically determine the data type when reading the CSV file All values are cast as a string You must define the data types for each file in import.conf You must cast any values other than a string using the appropriate Cypher function

When using the LOAD CSV statement in Cypher, the following statements apply:

• The database will automatically determine the data type when reading the CSV file: Neo4j attempts to automatically determine the data type of each column based on the content of the CSV file. It will try to infer the type (e.g., integer, float, boolean, date) where possible.

• All values are cast as a string: If Neo4j cannot determine the data type or if there is ambiguity, values will be read as strings.

• You must cast any values other than a string using the appropriate Cypher function : If you need to ensure that values are of a specific type (e.g., integer, float), you can use Cypher functions like toInt(), toFloat(), toBoolean(), etc., to cast the values after they have been loaded into the database.

The statement that does not apply is:

• You must define the data types for each file in import.conf : This is not accurate. While you can configure some aspects of the import process in the import configuration file, you do not need to define data types for each file there. Neo4j will automatically determine the data types, and you can use Cypher functions to cast values as needed within your LOAD CSV query.

Importing CSV files Complete the following Cypher statement to instruct Neo4j that the first row in the CSV file contains headers. cypher Copy LOAD CSV FROM 'file:///people.csv' AS row CREATE (p:Person) SET p += row

To instruct Neo4j that the first row in the CSV file contains headers, you need to add the WITH HEADERS clause to the LOAD CSV statement. Here's the completed Cypher statement:

cypher

LOAD CSV WITH HEADERS FROM 'file:///people.csv' AS row
CREATE (p:Person)
SET p += row

This statement does the following:

• LOAD CSV WITH HEADERS: Tells Neo4j that the first row of the CSV file contains column headers, not data.
• FROM 'file:///people.csv' AS row: Specifies the file to load and aliases each row as row.
• CREATE (p:Person): Creates a new node with the label Person.
• SET p += row: Sets the properties of the new Person node using the values from the row. The += operator is used to merge the properties from the row map into the p node, only setting properties that do not already exist on the node. If you want to overwrite existing properties, you can use the SET clause

Drivers When using a language driver, a statement of results comprises a stream of...​ nodes rows entries records ???

When using a language driver with Neo4j, a statement of results comprises a stream of records.

Each record represents a row in the result set and contains the values of the columns specified in the Cypher query. These records can include nodes, relationships, or scalar values, depending on the query. The term "record" is the most general term that can encompass all types of data returned by a Cypher query.

Drivers When establishing a driver connection using the neo4j+ssc, which of the following will occur? The driver will establish an unencrypted connection The driver will establish an encrypted connection and it will verify the SSL certificate The driver will establish an encrypted connection but it will not verify the SSL certificate

When establishing a driver connection using neo4j+ssc, which stands for "neo4j+s" (encrypted connection with SSL), "c" stands for "credentials":

The driver will establish an encrypted connection and it will verify the SSL certificate

This is because the +ssc URI scheme specifies that you want to use a secure socket connection with SSL encryption, and by default, it will also verify the SSL certificate to ensure that the connection is secure and the server is authenticated.

Library You can run a procedure in write mode multiple times to update existing properties. True False

True

You can run a procedure in write mode multiple times to update existing properties in Neo4j. Procedures are transactional and can be used to make changes to the graph, including updating node and relationship properties. If a procedure is designed to update properties and is run multiple times, it will apply the changes as specified in each execution, potentially updating properties that already exist.

Library Algorithms exist in one of three tiers of maturity. What are the tiers? Select all that apply. Production-quality Alpha Beta Gamma

In the context of Neo4j and its library of algorithms, the tiers of maturity for these algorithms are typically categorized as follows:

• Production-quality: Algorithms that are fully tested and ready for use in production environments.
• Alpha: Algorithms that are still in early development and may have limited functionality or be subject to change.
• Beta: Algorithms that are more developed than Alpha but not yet considered stable or complete enough for production use.

The option Gamma is not a recognized tier for the maturity of algorithms in Neo4j's context. Therefore, the correct tiers of maturity are:

• Production-quality
• Alpha
• Beta

Library What algorithm execution mode should you use to return the calculation results to the screen? stream stats mutate write

To return the calculation results to the screen when using algorithms in Neo4j, you should use the stats execution mode. This mode is designed to return metadata about the operation, including any results or statistics generated by the algorithm, without making changes to the graph data.

Library What utility function can you use to find a given node based on the node id? gds.util.matchNode() gds.util.findNode() gds.util.asNode() gds.util.returnNode()

根据搜索结果，用于根据节点ID查找特定节点的实用函数是 gds.util.asNode()。

Library The mutate mode will allow you to overwrite the mutateProperty from previous calculations. True False

False

The mutate mode in Neo4j graph algorithms is used to apply changes to the graph, such as setting or updating node or relationship properties. However, it does not automatically allow you to overwrite properties from previous calculations without explicitly specifying it in your algorithm or procedure.

When using the mutate mode, you need to be explicit about which properties you want to set or update. If you want to overwrite a property that might have been set in a previous calculation, you would typically need to include logic in your procedure or algorithm to handle this, rather than it being an automatic feature of the mutate mode itself.

Workflow How do you estimate memory requirements for the PageRank algorithm using the write mode? gds.pageRank.memory() gds.pageRank.write.estimate() gds.pageRank.estimate.write() gds.pageRank.estimate('write')

为了估计使用PageRank算法在写模式下的内存需求，你应该使用以下Cypher语句：

cypher

CALL gds.pageRank.write.estimate('myGraph', {
  writeProperty: 'pageRank',
  maxIterations: 20,
  dampingFactor: 0.85
})
YIELD nodeCount, relationshipCount, bytesMin, bytesMax, requiredMemory

这个语句会返回节点数量、关系数量、最小字节、最大字节和所需的内存估计。

Workflow Suppose you have a named graph in the Graph Catalog that contains the mutated node properties 'pageRank' and 'louvain'. How do you store the mutated properties back to Neo4j? gds.graph.nodeProperties.write('my-graph', ['pageRank', 'louvain']) gds.graph.writeBack('my-graph', ['pageRank', 'louvain']) gds.store.results('my-graph', ['pageRank', 'louvain']) gds.graph.writeRelationship('my-graph', ['pageRank', 'louvain'])

To store the mutated properties back to Neo4j from a named graph in the Graph Catalog, you should use the following procedure:

cypher

CALL gds.graph.nodeProperties.write('my-graph', ['pageRank', 'louvain'])

This procedure will take the named graph my-graph and the properties pageRank and louvain, and write them back to the nodes in the Neo4j graph. The other options provided are not the correct procedures for this task:

• gds.graph.writeBack('my-graph', ['pageRank', 'louvain']): This is not a valid procedure in the Neo4j Graph Data Science library.
• gds.store.results('my-graph', ['pageRank', 'louvain']): This is also not a valid procedure for writing node properties back to the graph.
• gds.graph.writeRelationship('my-graph', ['pageRank', 'louvain']): This procedure is used for writing relationship properties, not node properties.

Workflow How do you use a Cypher projection to create a graph that contains Person nodes and INTERACTS relationships that go only in the same direction as the relationships in the database? gds.graph.project.cypher( 'graph', 'MATCH (p:Person) RETURN id(p) as id', 'MATCH (s:Person)-[:INTERACTS]-(t:Person) RETURN id(s) as source, id(t) as target' ) MATCH (s:Person)-[r:INTERACTS]-(t:Person) RETURN gds.graph.project('graph', t, s, {relationshipType: type(r)}) MATCH (s:Person)-[r:INTERACTS]→(t:Person) RETURN gds.graph.project('graph', s, t, {relationshipType: type(r)}) gds.graph.project.cypher( 'graph', 'MATCH (p:Person) RETURN id(p) as id', 'MATCH (s:Person)-[:INTERACTS]→(t:Person) RETURN id(s) as source, id(t) as target', {relationshipOrientation:'UNDIRECTED'} )

To create a graph using Cypher projections that contains Person nodes and INTERACTS relationships that go only in the same direction as the relationships in the database, you would use the following Cypher statement:

cypher

MATCH (s:Person)-[r:INTERACTS]->(t:Person)
RETURN gds.graph.project('graph', s, t, {relationshipType: type(r)})

This statement does the following:

• MATCH (s:Person)-[r:INTERACTS]->(t:Person): Finds all INTERACTS relationships where the Person node s is the start node and Person node t is the end node, ensuring the direction is from s to t.
• RETURN gds.graph.project('graph', s, t, {relationshipType: type(r)}): Projects the Person nodes and INTERACTS relationships into a new graph named graph, preserving the direction of the relationships.

The other options are incorrect for the following reasons:

• gds.graph.project.cypher( 'graph', 'MATCH (p:Person) RETURN id(p) as id', 'MATCH (s:Person)-[:INTERACTS]-(t:Person) RETURN id(s) as source, id(t) as target' ): This would create an undirected graph, which is not what you want if you need to preserve the direction of the relationships.

• MATCH (s:Person)-[r:INTERACTS]-(t:Person) RETURN gds.graph.project('graph', t, s, {relationshipType: type(r)}): This would reverse the direction of the relationships, which is not the correct approach.

• gds.graph.project.cypher( 'graph', 'MATCH (p:Person) RETURN id(p) as id', 'MATCH (s:Person)-[:INTERACTS]→(t:Person) RETURN id(s) as source, id(t) as target', {relationshipOrientation:'UNDIRECTED'} ): This would create an undirected graph, which again is not the correct approach if you need to preserve the direction of the relationships.

Workflow What does the mutate mode of an algorithm do? Allows users to change the results of the algorithm. Writes the algorithm's results to the in-memory graph and returns a single record of summary statistics. Writes the algorithm's results to the Neo4j database and returns a single record of summary statistics. Returns the result of the algorithm as a stream of records.

The mutate mode of an algorithm in Neo4j does the following:

Writes the algorithm's results to the Neo4j database and returns a single record of summary statistics.

In the context of Neo4j's Graph Data Science (GDS) library, algorithms can be run in different modes, and the mutate mode is specifically designed to make changes to the graph, such as updating node or relationship properties with the results of an algorithm. After these changes are made, the algorithm returns a summary of what was done, typically in the form of a single record with statistics about the operation. This mode is useful for applying algorithmic results directly to the graph, such as setting node properties based on community detection or page rank scores.

Workflow Which node embedding techniques can encode both graph topology and node properties? FastRP GraphSAGE Node2Vec DeepWalk

根据提供的搜索结果，以下节点嵌入技术可以编码图拓扑和节点属性：

1. FastRP：FastRP算法在GDS库中扩展了原始算法，允许使用节点属性影响初始随机向量的创建。这意味着FastRP可以结合节点属性来生成嵌入，从而同时考虑图的拓扑结构和节点属性。

2. GraphSAGE：GraphSAGE算法利用节点特征（例如，文本属性、节点资料信息、节点度数）来学习一个泛化到未见节点的嵌入函数。它同时学习每个节点邻域的拓扑结构以及邻域内节点特征的分布。

因此，可以编码图拓扑和节点属性的节点嵌入技术包括FastRP和GraphSAGE。Node2Vec和DeepWalk主要是基于随机游走的方法，它们主要关注图的拓扑结构，而不直接结合节点属性进行嵌入。

Workflow How do you list all the projected named graphs in the Graph Catalog? gds.show.graphs() gds.graph.drop() gds.graph.list() gds.graph.create()

To list all the projected named graphs in the Graph Catalog in Neo4j, you would use the following procedure:

cypher

CALL gds.graph.list()
YIELD graph
RETURN graph

This gds.graph.list() procedure is used to retrieve a list of all graphs in the Graph Catalog, including projected named graphs. The other options provided are not used for listing graphs:

• gds.show.graphs(): This is not a valid procedure in the Neo4j Graph Data Science library.
• gds.graph.drop(): This procedure is used to drop a graph from the Graph Catalog, not to list them.
• gds.graph.create(): This procedure is used to create a new graph in the Graph Catalog, not to list existing ones.

Workflow What are the supported modes for executing graph algorithms? Select all that apply. stream mutate execute writ

查看网页详情

根据搜索结果，Neo4j Graph Data Science (GDS) 库支持的图算法执行模式有以下几种：

1. stream：以记录流的形式返回算法的结果。
2. mutate：将算法的结果写入内存中的图，并返回摘要统计信息的单个记录。
3. write：将算法的结果写入Neo4j数据库，并返回汇总统计的单个记录。
4. stats：返回摘要统计信息的单个记录，但不写入Neo4j数据库。

因此，所有这些模式都被支持：stream、mutate、write 和 stats。

Workflow What are the benefits of using a graph projection? Select all that apply. You can pick only analytically relevant portions of the database on which to act. You can only use them once, ensuring clarity on the results were calculated. They are compressed data structures optimized for topology and property lookup operations. The GDS library can act on either graph projections or the full database, so there is no benefit.

The benefits of using a graph projection in the context of Neo4j and graph analytics include:

1. You can pick only analytically relevant portions of the database on which to act. Graph projections allow you to focus on specific parts of your graph that are relevant to a particular analysis or algorithm, which can improve performance and reduce complexity.

2. They are compressed data structures optimized for topology and property lookup operations. Graph projections can be more efficient than working with the full database, especially when the full dataset is large. They can be optimized for specific types of queries and operations, making them faster for certain tasks.

The other options are not accurate:

• You can only use them once, ensuring clarity on the results were calculated. This statement is incorrect. Graph projections can be used multiple times and are not limited to single-use scenarios. They are versatile and can be reused for different analyses.

• The GDS library can act on either graph projections or the full database, so there is no benefit. This statement is misleading. While the GDS library can indeed act on both graph projections and the full database, the benefits of using graph projections include performance improvements, focusing on relevant data, and optimized data structures, as mentioned above.

In summary, the benefits of using graph projections are that they allow you to work with analytically relevant portions of the database and are optimized for certain operations.