Praktik terbaik untuk menjalankan algoritma di Spanner Graph

Dokumen ini menjelaskan praktik terbaik untuk menjalankan algoritma di Spanner Graph. Bagian ini membahas topik berikut:

Praktik terbaik skema grafik untuk algoritma

Jika Anda menggunakan label dan properti yang disesuaikan di Spanner Graph, sebaiknya selalu ekspos kunci elemen sebagai properti. Dengan cara ini, Anda dapat mengakses properti utama tersebut dalam klausa RETURN kueri algoritma, dan menggunakannya untuk mengidentifikasi elemen grafik yang outputnya dihasilkan oleh algoritma.

Menangani output algoritma

Bagian ini membagikan rekomendasi tentang apa yang harus ditampilkan dari output algoritma dan tempat untuk menyimpan hasil yang ditampilkan.

Yang harus dikembalikan

Jika tanda tangan output algoritma berisi elemen grafik, Spanner Graph memungkinkan Anda menampilkan properti apa pun dari elemen tersebut. Untuk mengurangi biaya pemrosesan, sebaiknya minimalkan daftar properti yang akan ditampilkan. Misalnya, hanya menampilkan properti yang merupakan kunci elemen karena kunci diperlukan untuk mengidentifikasi elemen.

Tempat untuk menyimpan

Spanner Graph mendukung persistensi hasil kueri algoritma ke Cloud Storage atau kembali ke instance Spanner Graph yang sama tempat Anda memulai kueri.

Mempertahankan kembali ke Spanner membuat output algoritma dapat diakses oleh semua operasi Spanner secara native. Misalnya, Anda dapat menjalankan WeaklyConnectedComponent, mempertahankan cluster_id kembali ke grafik. Selanjutnya, jalankan PageRank untuk grafik input dengan cluster_id tertentu. Fitur Spanner seperti Change Stream menyebarkan output algoritma baru ke sistem downstream. Jika Anda ingin menggunakan output algoritma di Spanner, sebaiknya teruskan ke Spanner. Meskipun Spanner Graph menggunakan cara yang efisien untuk mengelompokkan dan mempertahankan output algoritma ke Spanner, semua penulisan harus dilakukan melalui replika pemimpin yang sama. Jika Anda sudah memiliki workload penting yang menggunakan kapasitas pemimpin, sebaiknya lakukan penundaan pada eksekusi algoritma untuk menghindari persaingan dengan workload penting.

Pertimbangkan untuk mempertahankan ke Cloud Storage jika Anda tidak berencana menggunakan output algoritma di Spanner atau ingin mengevaluasi output algoritma sebelum memasukkannya ke sumber data utama Anda. Lihat format file yang didukung.

Pertimbangan pemodelan data untuk memperluas grafik

Bagian ini membahas beberapa pertimbangan pemodelan data saat mempertahankan output algoritma ke Spanner.

Properti versus tepi

Algoritma dapat menghasilkan berbagai insight, termasuk yang berikut:

  • Metrik tingkat node (misalnya, skor sentralitas). Properti ini dapat dipertahankan sebagai properti baru pada node.
  • Insight berpasangan (misalnya, kesamaan antara dua node). Nilai ini dapat dipertahankan sebagai tepi baru antara dua node dengan nilai output sebagai properti tepi.
  • Algoritma deteksi komunitas mengidentifikasi komunitas logis dalam grafik dan dapat menetapkan satu atau beberapa komunitas ke node tertentu. Anda dapat memodelkan keanggotaan komunitas sebagai properti baru di node dengan memberi tag pada setiap node anggota dengan ID komunitas yang ditetapkan. Anda juga dapat memodelkan keanggotaan komunitas sebagai subgraf baru dan menyimpan komunitas logis sebagai jenis node baru dalam grafik dengan edge yang menghubungkannya ke node anggota. Properti komunitas mungkin cukup jika Anda ingin mengetahui komunitas tempat node berada saat Anda mengakses node. Subgraf komunitas mungkin lebih tepat jika Anda ingin menjelajahi berdasarkan komunitas (misalnya, menemukan node dalam komunitas yang sama dengan node awal). Bergantung pada cara Anda berencana menggunakan informasi komunitas, Anda dapat memilih salah satu atau keduanya.

Skema yang telah ditentukan sebelumnya versus skema fleksibel

Sebelum Anda mempertahankan output algoritma kembali ke Spanner, tentukan kolom atau tabel tujuan dalam skema dengan salah satu cara berikut:

  • Jika kasus penggunaan algoritma Anda stabil dan diketahui, Anda dapat menambahkan kolom atau tabel tambahan sebelumnya.
  • Jika Anda melakukan iterasi dan bereksperimen dengan berbagai cara untuk mengekstrak insight (misalnya, mencoba berbagai algoritma, parameter, subgraf input), Anda mungkin menginginkan cara yang fleksibel untuk mempertahankan dan membedakan output dari beberapa eksperimen tanpa memperbarui skema Spanner untuk setiap eksekusi. Dalam hal ini, Anda dapat mempertimbangkan untuk menyimpan properti dan edge baru yang dihasilkan oleh algoritma dalam tabel turunan generik.

Untuk menyimpan properti dan edge baru yang dihasilkan oleh algoritma dalam tabel turunan generik, ikuti langkah-langkah berikut:

Langkah 1: Buat tabel turunan umum

-- Create `AccountAlgoProperty` as a child table of `Account`, to store all
-- properties produced by algorithms for `Account`.
-- `algo_run_id`: a unique ID for a given algorithm run.
-- `int_val`: column to store integer algorithm output.
-- `float_val`: column to store float algorithm output.
CREATE TABLE AccountAlgoProperty (
 id INT64 NOT NULL,
 algo_run_id STRING(200) NOT NULL,
 int_val INT64,
 float_val FLOAT64
) PRIMARY KEY(id, algo_run_id),
 INTERLEAVE IN PARENT Account;

-- Create `AccountAlgoEdge` as a child table of `Account`, to store all
-- outgoing edges produced by algorithms for `Account`.
-- `algo_run_id`: a unique ID for a given algorithm run.
-- `to_id`: destination `Account` id.
-- `int_val`: column to store integer algorithm output.
-- `float_val`: column to store float algorithm output.
CREATE TABLE AccountAlgoEdge (
 id INT64 NOT NULL,
 algo_run_id STRING(200) NOT NULL,
 to_id INT64 NOT NULL,
 int_val INT64,
 float_val FLOAT64,
 CONSTRAINT FK_AccountId FOREIGN KEY (to_id) REFERENCES Account (id) NOT ENFORCED,
) PRIMARY KEY(id, algo_run_id, to_id),
 INTERLEAVE IN PARENT Account;

Langkah 2: Simpan properti dan tepi yang dihasilkan oleh algoritma sebagai baris tabel turunan, bersama dengan algo_run_id unik yang menghasilkannya.

-- Store PageRank score as property in child table.
EXPORT DATA
 OPTIONS (format = "CLOUD_SPANNER",
          table = "AccountAlgoProperty",
          write_mode = 'upsert_ignore_all' ) AS
GRAPH FinGraph
CALL PageRank(node_labels => ['Account'], edge_labels => ['Transfers'])
RETURN node.id, "page_rank_123" AS algo_run_id, score As float_val;

-- Store ShortestPath output as edge in child table.
EXPORT DATA
 OPTIONS (format = "CLOUD_SPANNER",
          table = "AccountAlgoEdge",
          write_mode = 'upsert_ignore_all' ) AS
GRAPH FinGraph
CALL ShortestPath(
    source_nodes => ARRAY {
                      MATCH (n:Account {id: 7})
                      RETURN n
                    },
    target_nodes => ARRAY {
                      MATCH (n:Account {id: 16})
                      RETURN n
                    }
  ) YIELD source_node, target_node, path, cost
RETURN source_node.id AS id, "shortest_path_456" AS algo_run_id,
  target_node.id AS to_id, PATH_LENGTH(path) AS int_val, cost AS float_val;

Langkah 3: Akses output algoritma menggunakan GRAPH_TABLE

SELECT acct.id, prop.float_val AS page_rank_score
FROM GRAPH_TABLE(
  FinGraph
  MATCH (n:Account)
  RETURN n.id
) acct JOIN AccountAlgoProperty prop ON acct.id = prop.id
  AND prop.algo_run_id = 'page_rank_123';

SELECT acct.id, edge.to_id, edge.int_val AS path_len, edge.float_val AS cost
FROM GRAPH_TABLE(
  FinGraph
  MATCH (n:Account)
  RETURN n.id
) acct JOIN AccountAlgoEdge edge ON acct.id = edge.id
  AND edge.algo_run_id = 'shortest_path_456';

Langkah 4: Secara opsional, buat grafik logis yang dilengkapi dengan properti dan tepi yang dihasilkan algoritma untuk mempermudah akses ke output algoritma.

-- Create a view that aggregates non-null algorithm properties per node into
-- name-value pairs in JSON.
CREATE OR REPLACE VIEW AccountWithAlgoProperties SQL SECURITY INVOKER AS
SELECT
  n.id, ANY_VALUE(n.create_time) AS create_time,
  ANY_VALUE(n.is_blocked) AS is_blocked, ANY_VALUE(n.nick_name) AS nick_name,
  JSON_OBJECT(
    IF(COUNT(c.algo_run_id) = 0, [], ARRAY_AGG(c.algo_run_id)),
    IF(COUNT(c.algo_run_id) = 0, [], ARRAY_AGG(
      COALESCE(
        IF (c.int_val IS NULL, NULL, TO_JSON(c.int_val)),
        IF (c.float_val IS NULL, NULL, TO_JSON(c.float_val))
      )))) AS algo_props
FROM Account AS n LEFT JOIN AccountAlgoProperty AS c ON n.id = c.id
GROUP BY n.id;

-- Create FinGraphAugmented with algorithm generated properties and edges.
CREATE OR REPLACE PROPERTY GRAPH FinGraphAugmented
  NODE TABLES (
    AccountWithAlgoProperties AS Account
      KEY(id)
      LABEL Account PROPERTIES(
        create_time,
        id,
        is_blocked,
        nick_name,
        algo_props),
    Person
  )
  EDGE TABLES (
    PersonOwnAccount
      SOURCE KEY (id) REFERENCES Person (id)
      DESTINATION KEY (account_id) REFERENCES Account (id)
      LABEL Owns,
    AccountTransferAccount
      SOURCE KEY (id) REFERENCES Account (id)
      DESTINATION KEY (to_id) REFERENCES Account (id)
      LABEL Transfers,
    AccountAlgoEdge
      SOURCE KEY (id) REFERENCES Account (id)
      DESTINATION KEY (to_id) REFERENCES Account (id)
  );

Kemudian, Anda dapat langsung mengakses properti algoritma dan menjelajahi tepi yang dihasilkan algoritma dalam kueri grafik:

-- Retrieve PageRank score property in graph query.
GRAPH FinGraphAugmented
MATCH (a:Account)
RETURN a.id, a.algo_props.page_rank_123 AS page_rank
ORDER BY page_rank DESC
LIMIT 5;

-- Navigate through ShortestPath edge in graph query.
GRAPH FinGraphAugmented
MATCH (s:Account {id: 7})-[e:AccountAlgoEdge {algo_run_id : 'shortest_path_456'}]->(d:Account)
RETURN s.id AS src, d.id AS dst, e.int_val AS path_len, e.float_val AS cost

Menentukan machine_category untuk workload besar

Untuk sebagian besar workload, kategori mesin default sudah sesuai. Jika grafik input Anda memiliki > 1 miliar node dan > 10 miliar edge, sebaiknya pilih large secara eksplisit untuk machine_category.

Menggunakan kembali komputasi untuk iterasi cepat

Jika Anda bereksperimen dengan algoritma yang berbeda atau parameter input yang berbeda pada set data kecil untuk iterasi cepat, sebaiknya gunakan max_idle_time. Grafik Spanner max_idle_time yang lebih besar memungkinkan Anda menggunakan kembali resource komputasi yang telah disediakan untuk lebih banyak beban kerja algoritma. Hal ini mengurangi overhead untuk memulai komputasi dingin sesuai permintaan dan mengurangi risiko tidak dapat menyediakan komputasi karena kurangnya kapasitas sementara. Perhatikan bahwa komputasi algoritma dapat ditagih saat tidak ada aktivitas.

Membedakan jenis elemen dalam output

Jika output algoritma berisi beberapa jenis elemen, Anda mungkin ingin menyertakan ELEMENT_DEFINITION_NAME dalam output untuk membedakannya. Misalnya:

EXPORT DATA OPTIONS (
  uri = "gs://bucket-name/page_rank.csv",
  format = "csv",
  overwrite = TRUE) AS
GRAPH FinGraph
CALL PageRank()
YIELD node, score
RETURN ELEMENT_DEFINITION_NAME(node) AS node_type, node.id, score;

Langkah berikutnya