What I want to accomplish is that run a python script (in my case agent.py) inside a Spring Boot project via GraalVM.

I’ve installed GraalVM (ce jdk 21) and give it a path. Also define in the project structure and changed the pom.xml according to graalvm and graalvm’s python. Even though it gives an error that torch module couldn’t be found. I’ve also a conda env which has torch installed.

here’s the agent.py based on the this project, with slight changes

import torch
import random
import numpy as np
from collections import deque
import pandas as pd
import platform
import time
from game import SnakeGameAI, Direction, Point
from model import Linear_QNet, QTrainer
from helper import plot

MAX_MEMORY = 100_000
BATCH_SIZE = 1000
LR = 0.001

class Agent:

    def __init__(self):
        self.n_games = 0
        self.epsilon = 0 # randomness
        self.gamma = 0.9 # discount rate
        self.memory = deque(maxlen=MAX_MEMORY) # popleft()
        self.model = Linear_QNet(11, 256, 3)
        self.trainer = QTrainer(self.model, lr=LR, gamma=self.gamma)
        self.metrics = []
        self.start_time = time.time()

    def get_state(self, game):
        head = game.snake[0]
        point_l = Point(head.x - 20, head.y)
        point_r = Point(head.x + 20, head.y)
        point_u = Point(head.x, head.y - 20)
        point_d = Point(head.x, head.y + 20)
        
        dir_l = game.direction == Direction.LEFT
        dir_r = game.direction == Direction.RIGHT
        dir_u = game.direction == Direction.UP
        dir_d = game.direction == Direction.DOWN

        state = [
            # Danger straight
            (dir_r and game.is_collision(point_r)) or 
            (dir_l and game.is_collision(point_l)) or 
            (dir_u and game.is_collision(point_u)) or 
            (dir_d and game.is_collision(point_d)),

            # Danger right
            (dir_u and game.is_collision(point_r)) or 
            (dir_d and game.is_collision(point_l)) or 
            (dir_l and game.is_collision(point_u)) or 
            (dir_r and game.is_collision(point_d)),

            # Danger left
            (dir_d and game.is_collision(point_r)) or 
            (dir_u and game.is_collision(point_l)) or 
            (dir_r and game.is_collision(point_u)) or 
            (dir_l and game.is_collision(point_d)),
            
            # Move direction
            dir_l,
            dir_r,
            dir_u,
            dir_d,
            
            # Food location 
            game.food.x < game.head.x,  # food left
            game.food.x > game.head.x,  # food right
            game.food.y < game.head.y,  # food up
            game.food.y > game.head.y  # food down
            ]

        return np.array(state, dtype=int)

    def remember(self, state, action, reward, next_state, done):
        self.memory.append((state, action, reward, next_state, done)) # popleft if MAX_MEMORY is reached

    def train_long_memory(self):
        if len(self.memory) > BATCH_SIZE:
            mini_sample = random.sample(self.memory, BATCH_SIZE) # list of tuples
        else:
            mini_sample = self.memory

        states, actions, rewards, next_states, dones = zip(*mini_sample)
        self.trainer.train_step(states, actions, rewards, next_states, dones)
        #for state, action, reward, next_state, done in mini_sample:
        #    self.trainer.train_step(state, action, reward, next_state, done)

    def train_short_memory(self, state, action, reward, next_state, done):
        self.trainer.train_step(state, action, reward, next_state, done)

    def get_action(self, state):
        # random moves: tradeoff exploration / exploitation
        self.epsilon = 80 - self.n_games
        final_move = [0,0,0]
        if random.randint(0, 200) < self.epsilon:
            move = random.randint(0, 2)
            final_move[move] = 1
        else:
            state0 = torch.tensor(state, dtype=torch.float)
            prediction = self.model(state0)
            move = torch.argmax(prediction).item()
            final_move[move] = 1

        return final_move
    
    def save_metrics_excel(self, file_name='metrics.xlsx'):
        hardware_info = {
            'system': platform.system(),
            'machine': platform.machine(),
            'platform': platform.platform(),
            'processor': platform.processor(),
            'cpu_count': torch.cuda.device_count() if torch.cuda.is_available() else 0,
            'gpu': torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'None'
        }
        total_time = time.time() - self.start_time

        data = {
            'hardware_info': hardware_info,
            'total_training_time': total_time,
            'metrics': self.metrics
        }

        # Flatten data for the Excel file
        metrics_df = pd.DataFrame(self.metrics)
        hardware_df = pd.DataFrame([hardware_info])
        training_time_df = pd.DataFrame([{'total_training_time': total_time}])

        with pd.ExcelWriter(file_name) as writer:
            metrics_df.to_excel(writer, sheet_name='Metrics', index=False)
            hardware_df.to_excel(writer, sheet_name='Hardware', index=False)
            training_time_df.to_excel(writer, sheet_name='Training Time', index=False)


def train():
    plot_scores = []
    plot_mean_scores = []
    total_score = 0
    record = 0
    agent = Agent()
    game = SnakeGameAI()
    while True:
        # get old state
        state_old = agent.get_state(game)

        # get move
        final_move = agent.get_action(state_old)

        # perform move and get new state
        reward, done, score = game.play_step(final_move)
        state_new = agent.get_state(game)

        # train short memory
        agent.train_short_memory(state_old, final_move, reward, state_new, done)

        # remember
        agent.remember(state_old, final_move, reward, state_new, done)

        if done:
            # train long memory, plot result
            game.reset()
            agent.n_games += 1
            agent.train_long_memory()

            if score > record:
                record = score
                agent.model.save()

            print('Game', agent.n_games, 'Score', score, 'Record:', record)

            plot_scores.append(score)
            total_score += score
            mean_score = total_score / agent.n_games
            plot_mean_scores.append(mean_score)
            plot(plot_scores, plot_mean_scores)

            # Collect metrics
            agent.metrics.append({
                'Game': agent.n_games,
                'Score': score,
                'Record': record,
                'Mean Score': mean_score,
                'Timestamp': time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
            })

            # Save metrics to Excel periodically
            if agent.n_games % 10 == 0:  # Save every 10 games
                agent.save_metrics_excel()
            
            # Return a summary message
            return f'Training completed. Total games: {agent.n_games}, Final score: {score}, Record: {record}'


if __name__ == '__main__':
    train()

an the Spring Boot side

package com.rocksoft.denemeGraalVM;

import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.Source;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.io.File;
import java.io.IOException;

@Service
public class SnakeGameService {

    @Value("${python.script.path}")
    private String scriptPath;

    public void runGame() {
        try {
            // GraalVM context for Python execution
            Context context = Context.newBuilder("python")
                    .allowAllAccess(true)
                    .build();

            // Load and evaluate the Python script
            Source source = Source.newBuilder("python", new File(scriptPath)).build();
            context.eval(source);

            org.graalvm.polyglot.Value result = context.getBindings("python").getMember("train").execute();
            String gameStatus = result.asString();

            // Handle the result
            System.out.println("Game executed successfully. Status: " + gameStatus);

        } catch (IOException e) {
            e.printStackTrace();
            System.err.println("Failed to load the Python script: " + e.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("Error during Python script execution: " + e.getMessage());
        }
    }

    @Scheduled(fixedRate = 60000) // runs every 60 seconds
    public void scheduledGameRun() {
        runGame();
    }

}

also the dependencies I used

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.graalvm.sdk</groupId>
            <artifactId>graal-sdk</artifactId>
            <version>23.1.2</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.graalvm.polyglot/python-community -->
        <dependency>
            <groupId>org.graalvm.polyglot</groupId>
            <artifactId>python-community</artifactId>
            <version>23.1.2</version>
            <type>pom</type>
            <scope>runtime</scope>
        </dependency>


    </dependencies>

and the error

ModuleNotFoundError: No module named 'torch'
    at <python> <module>(Unknown)
    at org.graalvm.polyglot.Context.eval(Context.java:402)
    at com.rocksoft.denemeGraalVM.SnakeGameService.runGame(SnakeGameService.java:27)
    at com.rocksoft.denemeGraalVM.SnakeGameService.scheduledGameRun(SnakeGameService.java:46)
    at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:103)
    at java.base/java.lang.reflect.Method.invoke(Method.java:580)
    at org.springframework.scheduling.support.ScheduledMethodRunnable.runInternal(ScheduledMethodRunnable.java:130)
    at org.springframework.scheduling.support.ScheduledMethodRunnable.lambda$run$2(ScheduledMethodRunnable.java:124)
    at io.micrometer.observation.Observation.observe(Observation.java:499)
    at org.springframework.scheduling.support.ScheduledMethodRunnable.run(ScheduledMethodRunnable.java:124)
    at org.springframework.scheduling.support.DelegatingErrorHandlingRunnable.run(DelegatingErrorHandlingRunnable.java:54)
    at java.base/java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:572)
    at java.base/java.util.concurrent.FutureTask.runAndReset(FutureTask.java:358)
    at java.base/java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:305)
    at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1144)
    at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:642)
    at java.base/java.lang.Thread.run(Thread.java:1583)
Error during Python script execution: ModuleNotFoundError: No module named 'torch'

I’m open to any suggestions.