841770_fr-FR

liliconcom

Les opérations JSL de JMP Software peuvent-elles utiliser l’accélération GPU ?

Actuellement, il est facile d'exploiter l'accélération GPU pour les calculs en Python. Cela peut-il être réalisé en utilisant uniquement JSL ?

Merci les experts !

Windows 10 64 bits

Automatisation et scriptsFenêtresRé : Les opérations JSL de JMP Software peuvent-elles utiliser l’accélération GPU ?

Voici une réponse récente à un élément de discussion de MZWald du personnel JMP sur l'utilisation de plusieurs cœurs et des GPU

Certaines plateformes dans JMP n'utilisent qu'un seul thread, donc avoir plusieurs threads n'apporterait pas beaucoup de valeur ajoutée, mais avoir ce thread unique exécuté à une fréquence plus rapide ajouterait de la valeur. Certaines plateformes dans JMP tirent parti de plusieurs threads, donc avoir plus de threads/cœurs est utile.

Avec le module complémentaire Torch de JMP Pro 18, un GPU sera désormais utilisé pour la première fois pour la classification d'images et l'apprentissage en profondeur, ce qui permet d'effectuer ces tâches des ordres de grandeur plus rapidement qu'un processeur.

Ré : Les opérations JSL de JMP Software peuvent-elles utiliser l’accélération GPU ?

Ré : Les opérations JSL de JMP Software peuvent-elles utiliser l’accélération GPU ?

import pyopencl as cl
import pyopencl.array as cl_array
import numpy as np
import csv
import os
import time

# Select OpenCL platform and GPU device
platform = cl.get_platforms()[0]  # Select the first platform (e.g., AMD)
device = platform.get_devices()[0]  # Select the first GPU device (e.g., gfx804)
context = cl.Context([device])
queue = cl.CommandQueue(context)

# Define the GPU computation kernel (squares array elements)
kernel_code = """
__kernel void square(__global float *arr) {
    int gid = get_global_id(0);
    arr[gid] = arr[gid] * arr[gid];
}
"""
program = cl.Program(context, kernel_code).build()

# Create the CSV file path
csv_path = r"C:\0\results.csv"  # Changed to a more common name

# Ensure the directory exists
os.makedirs(os.path.dirname(csv_path), exist_ok=True)

# Run 10,000 computation tasks
n = 10**6  # 1 million data points per computation
num_iterations = 10_000

# Pre-allocate arrays
host_array = np.empty(n, dtype=np.float32)
gpu_array = cl_array.empty(queue, host_array.shape, dtype=host_array.dtype)

# Store results
results = []

# Random number generator
rng = np.random.default_rng()

# Start timing
start_time = time.time()

for i in range(num_iterations):
    # Generate random data and fill host_array
    host_array[:] = rng.random(n, dtype=np.float32)

    # Upload data to GPU
    cl.enqueue_copy(queue, gpu_array.data, host_array)

    # Compute on the GPU
    program.square(queue, gpu_array.shape, None, gpu_array.data)

    # Retrieve data from GPU
    cl.enqueue_copy(queue, host_array, gpu_array.data)

    # Record the first 5 results
    results.append([i + 1] + host_array[:5].tolist())

    # Progress display
    if (i + 1) % 100 == 0:
        print(f"Completed {i + 1}/{num_iterations} iterations...")

# Total time statistics
end_time = time.time()
total_time = end_time - start_time
print(f"Total time: {total_time:.2f} seconds")
print(f"Average time per iteration: {total_time / num_iterations:.6f} seconds")

# Write results to CSV in a single operation
with open(csv_path, "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["Iteration", "Result 1", "Result 2", "Result 3", "Result 4", "Result 5"])  # CSV header
    writer.writerows(results)

print(f":white_heavy_check_mark:</img> Computation complete, results saved to {csv_path}")

python
Comment puis-je utiliser JSL ?

Ré : Les opérations JSL de JMP Software peuvent-elles utiliser l’accélération GPU ?

Pour le moment, ce n'est pas possible.

L'utilisation de Python et de PyCUDA ou de pyOpenCL est à peu près le seul moyen d'accéder aux GPU à partir de scripts dans JMP. Comme indiqué dans l'un de mes articles précédents, vous pouvez créer des fonctions JSL définies par l'utilisateur qui implémentent des fonctionnalités en Python à l'aide de Python Execute(). De cette façon, vous pouvez écrire le code GPU en Python, tout en présentant une interface JSL pour le reste de votre script.