feat: implement GraphSAGE algorithm based on GeaFlow inference framework

.github/workflows/ci-jdk11.yml

@@ -74,6 +74,18 @@ jobs:
         with:
           version: "21.7"
 
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.9'
+          cache: 'pip'
+
+      - name: Install Python dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r geaflow/geaflow-dsl/geaflow-dsl-plan/src/main/resources/requirements.txt
+          pip list | grep -i torch
+
       # Current hive connector is incompatible with jdk11, implement 4.0.0+ hive version in later.
       - name: Build and Test On JDK 11
         run: |

.github/workflows/ci.yml

@@ -77,6 +77,18 @@ jobs:
         with:
           version: "21.7"
 
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.9'
+          cache: 'pip'
+
+      - name: Install Python dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r geaflow/geaflow-dsl/geaflow-dsl-plan/src/main/resources/requirements.txt
+          pip list | grep -i torch
+
       - name: Build and Test On JDK 8
         run: mvn -B -e clean test -Pjdk8 -pl !geaflow/geaflow-plugins/geaflow-store/geaflow-store-vector
         -Duser.timezone=Asia/Shanghai -Dlog4j.configuration="log4j .rootLogger=WARN, stdout"

geaflow/geaflow-common/src/main/java/org/apache/geaflow/common/config/keys/FrameworkConfigKeys.java

@@ -153,6 +153,16 @@ public class FrameworkConfigKeys implements Serializable {
         .noDefaultValue()
         .description("infer env conda url");
 
+    public static final ConfigKey INFER_ENV_USE_SYSTEM_PYTHON = ConfigKeys
+        .key("geaflow.infer.env.use.system.python")
+        .defaultValue(false)
+        .description("use system Python instead of creating virtual environment");
+
+    public static final ConfigKey INFER_ENV_SYSTEM_PYTHON_PATH = ConfigKeys
+        .key("geaflow.infer.env.system.python.path")
+        .noDefaultValue()
+        .description("path to system Python executable (e.g., /usr/bin/python3 or /opt/homebrew/bin/python3)");
+
     public static final ConfigKey ASP_ENABLE = ConfigKeys
         .key("geaflow.iteration.asp.enable")
         .defaultValue(false)

geaflow/geaflow-core/geaflow-api/src/main/java/org/apache/geaflow/api/graph/base/algo/AbstractIncVertexCentricComputeAlgo.java

@@ -34,4 +34,37 @@ public AbstractIncVertexCentricComputeAlgo(long iterations, String name) {
 
     public abstract FUNC getIncComputeFunction();
 
+    /**
+     * Returns the Python transform class name that this algorithm requires.
+     *
+     * <p>Override this method in subclasses to specify which Python UDF class
+     * should be loaded for inference, enabling multiple algorithms with different
+     * Python models to coexist in the same job without naming conflicts.
+     *
+     * <p>When this method returns a non-null value, the pipeline infrastructure
+     * will create a dedicated {@code InferContext} keyed to that class name,
+     * independent of the global {@code geaflow.infer.env.user.transform.classname}
+     * configuration. When it returns {@code null} (the default), the global
+     * configuration value is used.
+     *
+     * <p>Example:
+     * <pre>
+     *   // Using the default Python UDF specified in global config:
+     *   incGraphView.incrementalCompute(new GraphSAGECompute(10, 2))
+     *
+     *   // Explicitly specifying a Python UDF (code-based approach):
+     *   incGraphView.incrementalCompute(new GraphSAGECompute(10, 2, "GraphSAGETransFormFunction"))
+     *
+     *   // Two algorithms in the same job, each with its own Python UDF:
+     *   incGraphView.incrementalCompute(new GraphSAGECompute(10, 2, "GraphSAGETransFormFunction"))
+     *   incGraphView.incrementalCompute(new GCNCompute(64, "GCNTransFormFunction"))
+     * </pre>
+     *
+     * @return the Python transform class name, or {@code null} to fall back to
+     *         the global configuration
+     */
+    public String getPythonTransformClassName() {
+        return null;
+    }
+
 }

geaflow/geaflow-core/geaflow-runtime/geaflow-operator/src/main/java/org/apache/geaflow/operator/impl/graph/compute/dynamic/DynamicGraphVertexCentricComputeOp.java

@@ -20,8 +20,10 @@
 package org.apache.geaflow.operator.impl.graph.compute.dynamic;
 
 import java.io.IOException;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import org.apache.geaflow.api.function.iterator.RichIteratorFunction;
 import org.apache.geaflow.api.graph.base.algo.AbstractIncVertexCentricComputeAlgo;
@@ -33,6 +35,7 @@
 import org.apache.geaflow.common.config.keys.FrameworkConfigKeys;
 import org.apache.geaflow.common.exception.GeaflowRuntimeException;
 import org.apache.geaflow.infer.InferContext;
+import org.apache.geaflow.infer.InferContextPool;
 import org.apache.geaflow.model.graph.message.DefaultGraphMessage;
 import org.apache.geaflow.model.graph.vertex.IVertex;
 import org.apache.geaflow.model.record.RecordArgs.GraphRecordNames;
@@ -164,16 +167,62 @@ class IncGraphInferComputeContextImpl<OUT> extends IncGraphComputeContextImpl im
         public IncGraphInferComputeContextImpl() {
             if (clientLocal.get() == null) {
                 try {
-                    inferContext = new InferContext<>(runtimeContext.getConfiguration());
+                    // Build the effective configuration for this algorithm's InferContext.
+                    // If the algorithm declares its own Python transform class name
+                    // (code-based approach), override the global config with it so that
+                    // each algorithm can use an independent Python subprocess.
+                    // This resolves the UDF naming conflict when multiple algorithms
+                    // with different Python models run in the same job.
+                    Configuration inferConfig = buildInferConfig();
+                    inferContext = InferContextPool.getOrCreate(inferConfig);
+                    clientLocal.set(inferContext);
+                    LOGGER.info(
+                        "InferContext obtained from pool for algorithm '{}', "
+                            + "pythonTransformClass='{}', pool={}",
+                        function.getClass().getSimpleName(),
+                        inferConfig.getString(
+                            FrameworkConfigKeys.INFER_ENV_USER_TRANSFORM_CLASSNAME),
+                        InferContextPool.getStatus());
                 } catch (Exception e) {
-                    throw new GeaflowRuntimeException(e);
+                    LOGGER.error("Failed to obtain InferContext from pool", e);
+                    throw new GeaflowRuntimeException(
+                        "InferContext initialization failed: " + e.getMessage(), e);
                 }
-                clientLocal.set(inferContext);
             } else {
                 inferContext = clientLocal.get();
             }
         }
 
+        /**
+         * Builds the {@link Configuration} used for creating this algorithm's
+         * {@link InferContext}.
+         *
+         * <p>If the algorithm overrides {@link AbstractIncVertexCentricComputeAlgo
+         * #getPythonTransformClassName()} with a non-null value, a derived
+         * configuration is returned with that value set for
+         * {@code geaflow.infer.env.user.transform.classname}. This gives every
+         * algorithm its own {@code InferContext} (keyed by config hash in
+         * {@link InferContextPool}), so multiple algorithms with different Python
+         * UDFs can coexist in the same job without conflict.
+         *
+         * <p>If the algorithm returns {@code null} (the default), the runtime
+         * configuration is returned as-is, preserving the original behaviour.
+         */
+        private Configuration buildInferConfig() {
+            String algoClassName = function.getPythonTransformClassName();
+            if (algoClassName != null && !algoClassName.trim().isEmpty()) {
+                // Create a shallow copy of the global config and override the
+                // Python transform class name with the algorithm-specific value.
+                Map<String, String> overrideMap =
+                    new HashMap<>(runtimeContext.getConfiguration().getConfigMap());
+                overrideMap.put(
+                    FrameworkConfigKeys.INFER_ENV_USER_TRANSFORM_CLASSNAME.getKey(),
+                    algoClassName);
+                return new Configuration(overrideMap);
+            }
+            return runtimeContext.getConfiguration();
+        }
+
         @Override
         public OUT infer(Object... modelInputs) {
             try {
@@ -186,7 +235,9 @@ public OUT infer(Object... modelInputs) {
         @Override
         public void close() throws IOException {
             if (clientLocal.get() != null) {
-                clientLocal.get().close();
+                // Do NOT close the InferContext here since it's managed by the pool.
+                // The pool handles lifecycle management across the entire job.
+                LOGGER.debug("Detaching from pooled InferContext");
                 clientLocal.remove();
             }
         }

geaflow/geaflow-dsl/geaflow-dsl-plan/src/main/java/org/apache/geaflow/dsl/schema/function/BuildInSqlFunctionTable.java

@@ -232,15 +232,15 @@ public class BuildInSqlFunctionTable extends ListSqlOperatorTable {
             .add(GeaFlowFunction.of(IncMinimumSpanningTree.class))
             .add(GeaFlowFunction.of(ClosenessCentrality.class))
             .add(GeaFlowFunction.of(WeakConnectedComponents.class))
+            .add(GeaFlowFunction.of(ConnectedComponents.class))
+            .add(GeaFlowFunction.of(LabelPropagation.class))
+            .add(GeaFlowFunction.of(Louvain.class))
             .add(GeaFlowFunction.of(TriangleCount.class))
             .add(GeaFlowFunction.of(ClusterCoefficient.class))
             .add(GeaFlowFunction.of(IncWeakConnectedComponents.class))
             .add(GeaFlowFunction.of(CommonNeighbors.class))
             .add(GeaFlowFunction.of(JaccardSimilarity.class))
             .add(GeaFlowFunction.of(IncKHopAlgorithm.class))
-            .add(GeaFlowFunction.of(LabelPropagation.class))
-            .add(GeaFlowFunction.of(ConnectedComponents.class))
-            .add(GeaFlowFunction.of(Louvain.class))
             .build();
 
     public BuildInSqlFunctionTable(GQLJavaTypeFactory typeFactory) {