Communitygithub.com

NVlabs/Skill2Env

Se usa cuando un usuario solicita construir, optimizar, hacer backtesting, rebalancear o analizar un portafolio de acciones con Mean-CVaR, fronteras eficientes, generación de escenarios o NVIDIA cuOpt.

¿Qué es Skill2Env?

Este skill permite construir y analizar portafolios cuantitativos utilizando la optimización Mean-CVaR acelerada por NVIDIA. Con cuFOLIO, se pueden calcular rendimientos, generar escenarios KDE en GPU, resolver asignaciones de pesos con el solucionador cuOpt, trazar la frontera eficiente, realizar backtesting de portafolios y ejecutar flujos de rebalanceo a partir de datos de precios. Está diseñado para usarse con conjuntos de datos como el S&P 500, S&P 100, Dow 30 o archivos CSV proporcionados por el usuario. El skill está optimizado para entornos con GPU NVIDIA que tengan instalados cuOpt y cuML, y verifica la disponibilidad del solucionador GPU antes de ejecutar cualquier optimización. Incluye guardarraíles detallados para la validación de datos, manejo de restricciones personalizadas y generación de informes con métricas clave como el ratio Sharpe, Sortino y la máxima pérdida.

Compatible con~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/NVlabs/Skill2Env/tree/HEAD/SkillHub/skills/nvidia/cufolio

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Skill cuFOLIO

Propósito

Construir y analizar portafolios cuantitativos con la optimización Mean-CVaR acelerada por NVIDIA. Use cuFOLIO para calcular rendimientos, generar escenarios KDE, resolver asignaciones con el solucionador cuOpt en GPU, trazar una frontera eficiente, hacer backtesting de portafolios y ejecutar flujos de rebalanceo a partir de datos de precios.

Cuándo Usarlo

Use este skill cuando la tarea sea:

  • Construir u optimizar un portafolio Mean-CVaR a partir de precios de acciones.
  • Asignar pesos entre tickers mientras se controla el riesgo de cola CVaR.
  • Graficar o inspeccionar una frontera eficiente para un universo de portafolio.
  • Producir una tabla de pesos por aversión al riesgo.
  • Hacer backtesting de un portafolio optimizado contra benchmarks.
  • Rebalancear un portafolio según un calendario o un desencadenante de desviación.
  • Ejecutar flujos de trabajo en un conjunto de datos de precios S&P 500, S&P 100, Dow 30 o proporcionado por el usuario.

Las frases desencadenantes comunes incluyen "optimiza mi portafolio", "construye un portafolio CVaR", "usa cuFOLIO en estos tickers", "resuelve con cuOpt", "grafica la frontera eficiente", "muestra los pesos por aversión al riesgo", "haz backtesting de esta asignación", "rebalancea mensualmente", "analiza mis tenencias con CVaR", "compara asignaciones", "reduce el riesgo de cola", "construye una asignación", "evalúa opciones de asignación", "prueba de estrés mis tenencias", "evalúa la exposición al riesgo de cola", "revisa mis tenencias con límites de peso", "compara portafolios benchmark", "simula escenarios CVaR", "evalúa el riesgo del portafolio", "optimiza tenencias bajo restricciones" y "encuentra una asignación de menor riesgo".

No lo use para resúmenes financieros genéricos, predicción de precios, entrenamiento de redes neuronales, enrutamiento de vehículos u optimización no relacionada con portafolios.

Prerrequisitos

  • Entorno Python con el paquete cufolio instalado.
  • Tiempo de ejecución GPU NVIDIA con cuOpt y cuML instalados.
  • Extra de CUDA que coincida con el host, como uv sync --extra cuda12 o uv sync --extra cuda13.
  • cvxpy que exponga cp.CUOPT.
  • Acceso a red en la primera ejecución si el archivo CSV de precios predeterminado debe descargarse.

Configuración

Este skill utiliza el paquete cufolio instalado. Un entorno listo puede provenir del lanzable de Brev o de NVIDIA-AI-Blueprints/cuFOLIO después de instalar el extra de CUDA correspondiente.

En entornos de agentes/eval empaquetados, cufolio puede estar disponible a través de PYTHONPATH en lugar de como una rueda publicada por separado. Verifique el paquete local con python -c "import cufolio" antes de declararlo como faltante. No ejecute pip install cufolio, no reimplemente flujos de trabajo de cuFOLIO desde cero y no reemplace las APIs del paquete con código genérico de pandas/scipy/cvxpy para portafolios.

Para detalles de implementación concretos, use references/workflows/agent_recipes.md como la fuente de verdad. Contiene formas de trabajo exactas para cargar precios, preparar rendimientos, resolver con cuOpt, construir una frontera de 25 puntos, hacer backtesting contra peso igual y llamar al rebalanceador.

El conjunto de datos predeterminado es data/stock_data/sp500.csv. Está en gitignore. Antes de una descarga en la primera ejecución, informe al usuario que esto obtiene datos de mercado públicos a través del ayudante de datos cuFOLIO/yfinance y pídale que confirme:

import cvxpy as cp
from cufolio.cvar_parameters import CvarParameters
from cufolio.utils import download_data

download_data("data/stock_data", datasets=["sp500"])
SOLVER_SETTINGS = {"solver": cp.CUOPT, "verbose": False, "solver_method": "PDLP"}
cvar_params = CvarParameters(
    w_min=0.0, w_max=1.0,
    c_min=0.0, c_max=0.0,
    risk_aversion=1.0, confidence=0.95,
)

Instrucciones

Indique brevemente los valores predeterminados que se están aplicando antes de la ejecución, luego use estas barreras de seguridad:

  1. Cargue data/stock_data/sp500.csv; si falta, pregunte antes de descargar sp500 con cufolio.utils.download_data. No use glob, sustituciones ni fabrique datos de precios.
  2. Valide los CSV del usuario antes de resolver: requiera un índice similar a fecha o una primera columna de fecha, columnas de tickers numéricas, al menos 60 filas después del filtrado de fechas y al menos un ticker solicitado. Si el usuario proporciona fechas de inicio/fin, corte el DataFrame de precios antes del cálculo de rendimientos e informe el rango de fechas retenido. Filtre los tickers en el DataFrame de precios antes de que se calculen los rendimientos. regime_dict no toma un campo de ticker.
  3. Calcule rendimientos LOG con utils.calculate_returns(...).
  4. Genere escenarios con cvar_utils.generate_cvar_data(...), KDE y KDESettings(device="GPU").
  5. Defina CvarParameters con w_min y w_max explícitos. Para solicitudes ordinarias de "construir el portafolio óptimo", establezca c_min=0.0 y c_max=0.0 para que el resultado esté completamente invertido en lugar de 100% en efectivo.
  6. Construya cvar_optimizer.CVaR(returns_dict, cvar_params) directamente desde ese diccionario de rendimientos; mantenga tickers, arreglos de escenarios, medias y covarianzas en las formas devueltas por los ayudantes de cuFOLIO.
  7. Resuelva solo con NVIDIA cuOpt. Antes de resolver, verifique hasattr(cp, "CUOPT") y str(cp.CUOPT) in {str(s) for s in cp.installed_solvers()}. Pase SOLVER_SETTINGS a cada resolución única o resolución de frontera en bucle. Nunca recurra a CLARABEL, SCS, ECOS u otro solucionador de CPU. Si cuOpt está ausente, termine la validación/configuración e informe que el tiempo de ejecución de GPU/cuOpt falta en lugar de fabricar un resultado de CPU.
  8. Para restricciones personalizadas, mapee las solicitudes del usuario a CvarParameters: límites de peso a w_min/w_max, apetito de riesgo a risk_aversion, nivel de confianza a confidence, asignación de efectivo a c_max, y cardinalidad solo cuando el paquete exponga una restricción explícita de conteo de activos para el flujo de trabajo. Si las restricciones entran en conflicto (por ejemplo, un peso máximo demasiado bajo para invertir en la cantidad de tickers solicitada), explique el conflicto y pida que se relaje la restricción en lugar de adivinar.
  9. Si el usuario omite un benchmark para backtesting, use un portafolio de igual peso sobre los mismos tickers. Si el usuario omite una restricción, mantenga los valores predeterminados de la tabla y reafirme brevemente las suposiciones consecuentes antes de resolver.
  10. Entregue pesos ordenados por asignación, peso de efectivo, rendimiento esperado, CVaR, etiqueta del solucionador (cuOpt GPU) y cualquier figura de frontera, tabla de pesos, métricas de backtesting o calendario de rebalanceo solicitados. Para tablas, incluya tickers como columnas o filas con pesos decimales y porcentajes; para gráficos, conserve la figura de cuFOLIO devuelta en lugar de redibujar desde cero.
  11. Para respuestas de nivel de informe, incluya evidencia de que el flujo de trabajo solicitado realmente se ejecutó. Para una frontera eficiente, indique len(results_df) y use el ra_num solicitado (25 a menos que el usuario especifique lo contrario). Para una tabla de pesos, expanda results_df["weights"] en columnas de tickers e incluya cash más risk_aversion. Para un backtesting, incluya mean portfolio return, sharpe, sortino y max drawdown tanto para el portafolio optimizado como para el benchmark. Para rebalanceo, incluya results_dataframe, re_optimize_dates y la cola de cumulative_portfolio_value.

Esqueleto de Flujo de Trabajo Canónico

Comience las tareas positivas de cuFOLIO desde esta forma y adapte solo la salida solicitada. Para funciones copiables completas, lea references/workflows/agent_recipes.md antes de escribir código personalizado.

import cvxpy as cp
import pandas as pd

from cufolio import backtest, cvar_optimizer, cvar_utils, rebalance, utils
from cufolio.cvar_parameters import CvarParameters
from cufolio.portfolio import Portfolio
from cufolio.settings import KDESettings, ReturnsComputeSettings, ScenarioGenerationSettings

if not hasattr(cp, "CUOPT") or str(cp.CUOPT) not in {str(s) for s in cp.installed_solvers()}:
    raise RuntimeError("Se requiere el solucionador GPU cuOpt; no sustituya con un solucionador de CPU.")

SOLVER_SETTINGS = {"solver": cp.CUOPT, "verbose": False, "solver_method": "PDLP"}

prices = utils.get_input_data("data/stock_data/sp500.csv")
returns_dict = utils.calculate_returns(
    prices,
    regime_dict=None,
    returns_compute_settings=ReturnsComputeSettings(return_type="LOG"),
)
returns_dict = cvar_utils.generate_cvar_data(
    returns_dict,
    ScenarioGenerationSettings(
        fit_type="kde",
        kde_settings=KDESettings(device="GPU"),
    ),
)
cvar_params = CvarParameters(
    w_min=0.0,
    w_max=1.0,
    c_min=0.0,
    c_max=0.0,
    risk_aversion=1.0,
    confidence=0.95,
)
optimizer = cvar_optimizer.CVaR(returns_dict, cvar_params)
result, optimal_portfolio = optimizer.solve_optimization_problem(
    solver_settings=SOLVER_SETTINGS,
    print_results=False,
)

Para una frontera eficiente o tabla de pesos, llame:

results_df, fig, ax = cvar_utils.create_efficient_frontier(
    returns_dict,
    cvar_params,
    SOLVER_SETTINGS,
    ra_num=25,
    show_plot=False,
    show_discretized_portfolios=False,
    benchmark_portfolios=False,
    print_portfolio_results=False,
)
weights_table = pd.DataFrame(results_df["weights"].tolist(), index=results_df.index)

Para un backtesting con benchmark, envuelva la asignación resuelta en Portfolio(name="cuOpt Optimal", tickers=returns_dict["tickers"], weights=optimal_portfolio.weights, cash=optimal_portfolio.cash), cree un Portfolio de igual peso sobre los mismos returns_dict["tickers"], luego use backtest.portfolio_backtester(..., test_method="historical").backtest_against_benchmarks(...). El backtester devuelve (backtest_results, ax).

Para rebalanceo mensual, primero escriba el DataFrame de precios en una ruta CSV. Instancie rebalance.rebalance_portfolio(dataset_directory=<csv_path>, ...) con re_optimize_criteria={"type": "drift_from_optimal", "threshold": 0, "norm": 1} y llame a re_optimize(transaction_cost_factor=..., plot_title="Rebalanceo Mensual"). El rebalanceador devuelve (results_dataframe, re_optimize_dates, cumulative_portfolio_value).

Datos y Valores Predeterminados

ConfiguraciónValor Predeterminado
Conjunto de datosdata/stock_data/sp500.csv
Rango de fechasRango completo disponible
Tipo de portafolioSolo largo
Peso máximoNinguno a menos que se especifique
Aversión al riesgo1.0
Confianza0.95
Método de escenarioKDE en GPU
SolucionadorcuOpt GPU con PDLP
RebalanceoNinguno a menos que se solicite

El archivo predeterminado del S&P 500 es una instantánea histórica y puede omitir los componentes actuales. Los CSV proporcionados por el usuario deben ser tablas de precios indexadas por fecha con columnas de tickers, compatibles con utils.get_input_data. Si los tickers solicitados están ausentes, elimínelos, informe las omisiones y continúe con las columnas disponibles a menos que el usuario solicite explícitamente obtener otros datos.

APIs Clave

Use las APIs del paquete en lugar de reimplementar matemáticas de portafolio o bucles de simulación. Los ayudantes de cuFOLIO devuelven objetos planos: returns_dict tiene claves como returns, mean, covariance y tickers; no lo indexe como returns_dict["regime_1"]. solve_optimization_problem(...) devuelve (result_row, portfolio), no un diccionario de resultados anidado.

  • Rendimientos: utils.calculate_returns(input_dataset, regime_dict, returns_compute_settings).
  • Filtro de régimen: regime_dict es None o {"name": "...", "range": ("YYYY-MM-DD", "YYYY-MM-DD")}; no está indexado por nombre de régimen y no contiene tickers.
  • Escenarios: cvar_utils.generate_cvar_data(returns_dict, scenario_generation_settings).
  • Optimizador: cvar_optimizer.CVaR(returns_dict, cvar_params).
  • Resolución: result_row, portfolio = cvar_problem.solve_optimization_problem(solver_settings=SOLVER_SETTINGS, print_results=False).
  • Frontera eficiente: cvar_utils.create_efficient_frontier(returns_dict, cvar_params, solver_settings=SOLVER_SETTINGS, ra_num=25). El results_df devuelto incluye métricas, una columna de diccionario weights y cash.
  • Portafolio: Portfolio(name="", tickers=None, weights=None, cash=0.0, time_range=None); pase tickers y un arreglo plano similar a weights alineado con esos tickers.
  • Backtesting: cree objetos portfolio.Portfolio para la asignación optimizada y cada benchmark; para un benchmark de igual peso, use pesos de 1 / len(tickers) y cash=0.0, luego llame a backtest.portfolio_backtester(test_portfolio, returns_dict, risk_free_rate=0.0, test_method="historical", benchmark_portfolios=[...]).backtest_against_benchmarks(...).
  • Rebalanceo: rebalance.rebalance_portfolio(...) requiere que dataset_directory sea una ruta CSV, no un DataFrame. Llame a re_optimize(...); devuelve (results_dataframe, re_optimize_dates, cumulative_portfolio_value).
  • Modelos de configuración: ReturnsComputeSettings, ScenarioGenerationSettings, KDESettings, ApiSettings y CvarParameters.

Ejemplos

  • "Construye el portafolio óptimo del S&P 500": cargue precios, calcule rendimientos LOG, genere escenarios KDE en GPU, establezca CvarParameters de solo largo totalmente invertido, resuelva con cuOpt e informe pesos diversificados más rendimiento/CVaR.
  • "Grafica la frontera eficiente": llame a create_efficient_frontier(...), devuelva results_df y muestre o guarde la figura según lo solicitado.
  • "Dame los pesos por aversión al riesgo": expanda results_df["weights"] en una tabla por activo.
  • "Haz backtesting contra peso igual": construya los objetos Portfolio optimizado y de igual peso, luego use el backtester de cuFOLIO e informe Sharpe, Sortino y máxima pérdida.
  • "Haz backtesting con rebalanceo mensual": configure rebalance_portfolio con el desencadenante de desviación anterior y ejecute re_optimize(transaction_cost_factor=...).

Limitaciones

  • Requiere una GPU NVIDIA con cuOpt y cuML; los solucionadores de CPU están intencionalmente deshabilitados.
  • Los contenedores de evaluación solo con CPU aún pueden validar el enrutamiento, el manejo de datos y el comportamiento de informes, pero no pueden producir una resolución válida de cuOpt. En ese caso, informe explícitamente la falta de tiempo de ejecución de GPU/cuOpt.
  • Los datos de precios predeterminados son una instantánea histórica y pueden omitir los componentes actuales.
  • La descarga del conjunto de datos en la primera ejecución depende del acceso a la red a menos que el usuario proporcione un CSV.

Solución de Problemas

  • Archivo CSV predeterminado faltante o FileNotFoundError: explique que cuFOLIO obtendrá datos de mercado públicos con download_data("data/stock_data", datasets=["sp500"]); ejecútelo solo después de la confirmación del usuario.
  • SolverError o cp.CUOPT faltante: instale el extra de CUDA que coincida con el host y verifique con python -c "import cvxpy as cp; print(hasattr(cp, 'CUOPT'), cp.installed_solvers())".
  • ImportError o función faltante de cuFOLIO: verifique que el paquete esté instalado y que la ruta esté en PYTHONPATH (en entornos empaquetados).
  • Datos de precios insuficientes: confirme que el CSV tenga al menos 60 filas y al menos un ticker solicitado, o pida un conjunto de datos más grande.
  • Las restricciones no cuadran: describa el conflicto y pida al usuario que relaje un límite (por ejemplo, w_max para cubrir todos los tickers) en lugar de elegir un valor arbitrario.

Notas Adicionales

  • Mantenga los resultados de la resolución como objetos planos de Python (DataFrame, Portafolio, figura de matplotlib).
  • No serialice ni convierta las figuras a base64; devuélvalas directamente.
  • Para informes completos, incluya tanto los mensajes de texto como los artefactos visuales (por ejemplo, figura de la frontera, tabla de backtesting).
  • Si el usuario solicita una comparación con benchmarks, presente una tabla lado a lado con métricas para cada portafolio.
  • El código de rebalanceo requiere que la ruta del CSV se pase como dataset_directory; no use un DataFrame directamente.
  • Para activar el rebalanceo por desviación, use re_optimize_criteria con "drift_from_optimal" y un umbral de 0 para rebalancear en cada fecha del historial.
  • Los valores predeterminados de w_min=0.0, w_max=1.0, c_min=0.0, c_max=0.0 garantizan una asignación totalmente invertida y solo larga, a menos que el usuario especifique lo contrario.
  • La frontera eficiente generada por create_efficient_frontier puede incluir puntos no convexos debido a la discretización; no la suavice ni la interpole.
  • Para backtesting, el portafolio de igual peso es un benchmark común; si el usuario no proporciona uno, asuma ese valor predeterminado e infórmelo.

Individual skills in this repo

This repo contains 13 individual skills — each has its own dedicated page.

NVlabs/Skill2Env

This skill should be used when the user asks about "digital portfolio", "portfolio website", "project description", "case study", "portfolio curation", "creative portfolio", "act as a portfolio curator", "portfolio curator mode", "portfolio review", "professional presentation", "portfolio architecture", "work samples", "portfolio bio", or needs expertise in building, structuring, and writing professional digital portfolios. Part of the AlterLab FC Skills collection (New Media & Communication department).

NVlabs/Skill2Env

This skill should be used when the user asks about "web content strategy", "SEO writing", "UX writing", "information architecture", "content architecture", "website structure", "act as a web content strategist", "web strategist mode", "site map", "content audit", "microcopy", "meta descriptions", "content hierarchy", "content governance", or needs expertise in planning, structuring, and writing content for websites and digital platforms. Part of the AlterLab FC Skills collection (New Media & Communication department).

NVlabs/Skill2Env

When the user wants to create, generate, or produce video content using AI tools or programmatic frameworks. Also use when the user mentions 'video production,' 'AI video,' 'Remotion,' 'Hyperframes,' 'HeyGen,' 'Synthesia,' 'Veo,' 'Sora,' 'Runway,' 'Kling,' 'Seedance,' 'Hailuo,' 'MiniMax,' 'Pika,' 'Hunyuan,' 'Wan,' 'video generation,' 'AI avatar,' 'talking head video,' 'programmatic video,' 'video template,' 'explainer video,' 'product demo video,' 'video pipeline,' or 'make me a video.' Use this for video creation, generation, and production workflows. For video content strategy and what to post, see social. For paid video ad creative, see ad-creative.

NVlabs/Skill2Env

Balance visual design with ATS compatibility for creative roles

NVlabs/Skill2Env

Build immersive, cinematic 2.5D interactive websites using scroll storytelling, parallax depth, text animations, and premium scroll effects — no WebGL required. Use this skill for any web design task: landing pages, product sites, hero sections, scroll animations, parallax, sticky sections, section overlaps, floating products between sections, clip-path reveals, text that flies in from sides, words that light up on scroll, curtain drops, iris opens, card stacks, bleed typography, and any site that should feel cinematic or premium. Trigger on phrases like "make it feel alive", "Apple-style animation", "sections that overlap", "product rises between sections", "immersive", "scrollytelling", or any scroll-driven visual effect. Covers 45+ techniques across 8 categories. Always inspects, judges, and plans assets before coding. Use aggressively for ANY web design task.

NVlabs/Skill2Env

Read-only queue dashboard for workspace-aware ship. (gstack)

NVlabs/Skill2Env

Guidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults.

NVlabs/Skill2Env

Audits any landing or service page across 48 checks in 10 categories for LLM/AI discoverability, GEO readiness, content clarity, schema markup, internal linking, freshness signals, and technical crawlability. Produces an overall score out of 100, a per-category score out of 100, pass/warn/fail/ manual counts, and a prioritised fix list — all rendered as a standalone HTML report saved to disk. Use when a user provides a URL and asks to audit it, score it, check its GEO readiness, test its AI discoverability, run a landing page audit, or evaluate it for LLM citation potential. Also trigger on phrases like "audit this page", "score this URL", "check GEO for", "is this page AI-ready", "run a GEO audit", "LLM page check", "how would AI read this page", or "landing page score".

NVlabs/Skill2Env

Generates a premium single-page HTML landing page with 3D CSS animations, GSAP scroll effects, and mouse-parallax depth. Forcing intake (product + elevator pitch, audience register, brand overrides, tone) locks down positioning before any copy or markup is written, so the page reflects the actual product rather than generic boilerplate. Use whenever the user says 'landing for X', 'create a landing page', 'build a landing page', 'make a landing page for X', 'I need a web page for Y', or provides product/service details and wants a polished website. Also triggers on 'promotional page', 'product page', 'one-pager', 'web presence', 'sales page'. Outputs a single self-contained HTML file (Claude Code) or HTML artifact (Claude.ai). Supports configurable brand colors via CSS custom property overrides.

NVlabs/Skill2Env

Transform resume bullets into detailed portfolio case studies

NVlabs/Skill2Env

Generates high-converting landing pages as complete Next.js/React (TSX) components with Tailwind CSS. Creates hero sections, feature grids, pricing tables, FAQ accordions, testimonial blocks, and CTA sections using proven copy frameworks (PAS, AIDA, BAB). Outputs SEO meta tags, structured data, and performance-optimised code targeting Core Web Vitals (LCP < 1s, CLS < 0.1). Use when the user asks to create a landing page, marketing page, homepage, single-page site, lead capture page, campaign page, promo page, or conversion-optimised web page — or when they want to A/B test landing page variants or replace a static page with one designed to convert.

NVlabs/Skill2Env

> Visual design direction framework organized by emotional intent (Warm/Cold x Active/Calm). The first design reference system that categorizes sites by what they make you FEEL, not how they look. Includes 48 annotated public website references.

NVlabs/Skill2Env

Run a structured 5-pass finishing audit on any website before launch — scoring visual polish, technical foundation, UX completeness, content quality, and cross-device readiness on 100 points. Use when: **Pre-launch** - Final validation before going live; **Post-redesign** - Verify nothing broke during the overhaul; **Client handoff** - Structured proof that the site is ready; **Quarterly review** - Catch accumulated debt; **Single-pass focus** - Run just Pass 2 after a perf sprint

Skills relacionados