Communitygithub.com

NVlabs/Skill2Env

Use quando um usuário solicitar construir, otimizar, backtestar, rebalancear ou analisar um portfólio de ações com Mean-CVaR, fronteiras eficientes, geração de cenários ou NVIDIA cuOpt.

O que é Skill2Env?

Esta skill capacita um agente de IA a construir e analisar portfólios quantitativos usando otimização Mean-CVaR acelerada por GPU da NVIDIA, através do pacote cuFOLIO. Ela é ideal para cenários como alocação de ativos com controle de risco de cauda (CVaR), traçado de fronteiras eficientes, backtesting contra benchmarks e rebalanceamento periódico de portfólios. A skill depende de uma GPU NVIDIA com as bibliotecas cuOpt e cuML para resolver os problemas de otimização, usando o solver PDLP do cuOpt para garantir desempenho máximo. O fluxo de trabalho típico envolve carregar dados de preços (como o dataset S&P 500 padrão), calcular retornos logarítmicos, gerar cenários via KDE na GPU, configurar parâmetros de risco (pesos mínimo/máximo, aversão ao risco, confiança) e resolver a alocação ótima. A skill também suporta backtesting histórico, comparação com benchmarks de peso igual e rebalanceamento baseado em desvio. É importante notar que a skill não funciona em ambientes sem GPU NVIDIA adequada, e os dados de preços padrão são um snapshot histórico que pode não refletir a composição atual do índice.

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

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Skill cuFOLIO

Propósito

Construir e analisar portfólios quantitativos com otimização Mean-CVaR acelerada por NVIDIA. Use cuFOLIO para calcular retornos, gerar cenários KDE, resolver alocações com o solver GPU cuOpt, traçar uma fronteira eficiente, realizar backtest de portfólios e executar fluxos de rebalanceamento a partir de dados de preços.

Quando Usar

Use esta skill quando a tarefa for:

  • Construir ou otimizar um portfólio Mean-CVaR a partir de preços de ações.
  • Alocar pesos entre ativos enquanto controla o risco CVaR de cauda.
  • Plotar ou inspecionar uma fronteira eficiente para um universo de portfólio.
  • Produzir uma tabela de pesos por aversão ao risco.
  • Backtestar um portfólio otimizado contra benchmarks.
  • Rebalancear um portfólio em uma agenda programada ou por gatilho de desvio.
  • Executar fluxos em um dataset S&P 500, S&P 100, Dow 30 ou fornecido pelo usuário.

Frases de gatilho comuns incluem "otimize meu portfólio", "construa um portfólio CVaR", "use cuFOLIO nestes tickers", "resolva com cuOpt", "plote a fronteira eficiente", "mostre pesos por aversão ao risco", "backteste esta alocação", "rebalanceie mensalmente", "analise meus ativos com CVaR", "compare alocações", "reduza o risco de cauda", "construa uma alocação", "avalie opções de alocação", "stress-teste meus ativos", "avalie exposição ao risco de cauda", "revise meus ativos sob limites de peso", "compare portfólios de benchmark", "simule cenários CVaR", "analise risco do portfólio", "otimize ativos sob restrições" e "encontre uma alocação de menor risco".

Não use para resumos financeiros genéricos, previsão de preços, treinamento de redes neurais, roteamento de veículos ou otimização não relacionada a portfólios.

Pré-requisitos

  • Ambiente Python com o pacote cufolio instalado.
  • GPU NVIDIA com cuOpt e cuML instalados.
  • Extra CUDA correspondente ao host, como uv sync --extra cuda12 ou uv sync --extra cuda13.
  • cvxpy expondo cp.CUOPT.
  • Acesso à rede na primeira execução se o CSV de preços padrão precisar ser baixado.

Configuração

Esta skill utiliza o pacote cufolio instalado. Um ambiente pronto pode vir do Brev launchable ou de NVIDIA-AI-Blueprints/cuFOLIO após instalar o extra CUDA correspondente.

Em sandboxes de agentes/avaliação empacotados, cufolio pode estar disponível via PYTHONPATH em vez de uma wheel publicada separadamente. Verifique o pacote local com python -c "import cufolio" antes de declará-lo ausente. Não execute pip install cufolio, não reimplemente fluxos cuFOLIO do zero e não substitua as APIs do pacote por código genérico de portfólio com pandas/scipy/cvxpy.

Para detalhes de implementação concretos, use references/workflows/agent_recipes.md como fonte da verdade. Ele contém formas exatas de trabalho para carregar preços, preparar retornos, resolver com cuOpt, construir uma fronteira de 25 pontos, backtestar contra peso igual e chamar o rebalanceador.

O dataset padrão é data/stock_data/sp500.csv. Ele está no .gitignore. Antes de um download na primeira execução, informe ao usuário que isso busca dados de mercado públicos através do helper de dados cuFOLIO/yfinance e peça confirmação:

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,
)

Instruções

Declare brevemente os padrões sendo aplicados antes da execução, depois use estas diretrizes:

  1. Carregue data/stock_data/sp500.csv; se estiver faltando, peça antes de baixar sp500 com cufolio.utils.download_data. Não use glob, substitua ou fabrique dados de preços.
  2. Valide CSVs do usuário antes de resolver: exija um índice do tipo data ou primeira coluna de data, colunas de ticker numéricas, pelo menos 60 linhas após filtragem por data e pelo menos um ticker solicitado. Se o usuário fornecer datas de início/fim, fatie o DataFrame de preços antes do cálculo de retornos e informe o intervalo de datas retido. Filtre tickers no DataFrame de preços antes de calcular retornos. regime_dict não aceita um campo ticker.
  3. Calcule retornos LOG com utils.calculate_returns(...).
  4. Gere cenários com cvar_utils.generate_cvar_data(...), KDE e KDESettings(device="GPU").
  5. Defina CvarParameters com w_min e w_max explícitos. Para solicitações comuns de "construir o portfólio ótimo", defina c_min=0.0 e c_max=0.0 para que o resultado seja totalmente investido em vez de 100% em dinheiro.
  6. Construa cvar_optimizer.CVaR(returns_dict, cvar_params) diretamente a partir desse dicionário de retornos; mantenha tickers, arrays de cenário, médias e covariância nas formas retornadas pelos helpers do cuFOLIO.
  7. Resolva apenas com NVIDIA cuOpt. Antes de resolver, verifique hasattr(cp, "CUOPT") e str(cp.CUOPT) in {str(s) for s in cp.installed_solvers()}. Passe SOLVER_SETTINGS para cada resolução única ou em loop de fronteira. Nunca recorra a CLARABEL, SCS, ECOS ou outro solver de CPU. Se cuOpt estiver ausente, finalize validação/configuração e reporte que o runtime GPU/cuOpt está faltando em vez de fabricar um resultado de CPU.
  8. Para restrições personalizadas, mapeie solicitações do usuário para CvarParameters: limites de peso para w_min/w_max, apetite ao risco para risk_aversion, nível de confiança para confidence, tolerância a dinheiro para c_max, e cardinalidade apenas quando o pacote expuser uma restrição explícita de contagem de ativos para o fluxo. Se as restrições entrarem em conflito (por exemplo, um peso máximo muito baixo para investir no número solicitado de tickers), explique o conflito e peça para a restrição ser relaxada em vez de adivinhar.
  9. Se o usuário omitir um benchmark para backtesting, use um portfólio de peso igual sobre os mesmos tickers. Se o usuário omitir uma restrição, mantenha os valores padrão da tabela e reafirme brevemente as suposições consequentes antes de resolver.
  10. Entregue pesos ordenados por alocação, peso em dinheiro, retorno esperado, CVaR, rótulo do solver (cuOpt GPU) e qualquer figura de fronteira solicitada, tabela de pesos, métricas de backtest ou cronograma de rebalanceamento. Para tabelas, inclua tickers como colunas ou linhas com pesos decimais e percentuais; para gráficos, preserve a figura retornada pelo cuFOLIO em vez de redesenhar do zero.
  11. Para respostas de nível de relatório, inclua evidências de que o fluxo solicitado realmente foi executado. Para uma fronteira eficiente, informe len(results_df) e use o ra_num solicitado (25 a menos que o usuário especifique o contrário). Para uma tabela de pesos, expanda results_df["weights"] em colunas de ticker e inclua cash mais risk_aversion. Para um backtest, inclua mean portfolio return, sharpe, sortino e max drawdown tanto para o portfólio otimizado quanto para o benchmark. Para rebalanceamento, inclua results_dataframe, re_optimize_dates e o final de cumulative_portfolio_value.

Esqueleto de Fluxo Canônico

Inicie tarefas cuFOLIO positivas a partir desta forma e adapte apenas a saída solicitada. Para funções copiáveis completas, leia references/workflows/agent_recipes.md antes de escrever 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("cuOpt GPU solver is required; do not substitute a CPU solver.")

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,
    scenario_generation_settings=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 uma fronteira eficiente ou tabela de pesos, chame:

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 um backtest com benchmark, envolva a alocação resolvida em Portfolio(name="cuOpt Optimal", tickers=returns_dict["tickers"], weights=optimal_portfolio.weights, cash=optimal_portfolio.cash), crie um Portfolio de peso igual sobre os mesmos returns_dict["tickers"], então use backtest.portfolio_backtester(..., test_method="historical").backtest_against_benchmarks(...). O backtester retorna (backtest_results, ax).

Para rebalanceamento mensal, escreva o DataFrame de preços primeiro em um caminho CSV. Instancie rebalance.rebalance_portfolio(dataset_directory=<csv_path>, ...) com re_optimize_criteria={"type": "drift_from_optimal", "threshold": 0, "norm": 1} e chame re_optimize(transaction_cost_factor=..., plot_title="Monthly Rebalancing"). O rebalanceador retorna (results_dataframe, re_optimize_dates, cumulative_portfolio_value).

Dados e Padrões

ConfiguraçãoPadrão
Datasetdata/stock_data/sp500.csv
Intervalo de datasIntervalo completo disponível
Tipo de portfólioApenas comprado (long-only)
Peso máximoNenhum a menos que especificado
Aversão ao risco1.0
Confiança0.95
Método de cenárioKDE na GPU
SolvercuOpt GPU com PDLP
RebalanceamentoNenhum a menos que solicitado

O arquivo S&P 500 padrão é um snapshot histórico e pode omitir constituintes atuais. CSVs fornecidos pelo usuário devem ser tabelas de preços indexadas por data com colunas de ticker, compatíveis com utils.get_input_data. Se tickers solicitados estiverem ausentes, remova-os, reporte as omissões e continue com as colunas disponíveis, a menos que o usuário peça explicitamente para buscar outros dados.

Principais APIs

Use as APIs do pacote em vez de reimplementar matemática de portfólio ou loops de simulação. Os helpers do cuFOLIO retornam objetos planos: returns_dict tem chaves como returns, mean, covariance e tickers; não o indexe como returns_dict["regime_1"]. solve_optimization_problem(...) retorna (result_row, portfolio), não um dicionário de resultado aninhado.

  • Retornos: utils.calculate_returns(input_dataset, regime_dict, returns_compute_settings).
  • Filtro de regime: regime_dict é None ou {"name": "...", "range": ("YYYY-MM-DD", "YYYY-MM-DD")}; não é chaveado por nome de regime e não contém tickers.
  • Cenários: cvar_utils.generate_cvar_data(returns_dict, scenario_generation_settings).
  • Otimizador: cvar_optimizer.CVaR(returns_dict, cvar_params).
  • Resolver: result_row, portfolio = cvar_problem.solve_optimization_problem(solver_settings=SOLVER_SETTINGS, print_results=False).
  • Fronteira eficiente: cvar_utils.create_efficient_frontier(returns_dict, cvar_params, solver_settings=SOLVER_SETTINGS, ra_num=25). O results_df retornado inclui métricas, uma coluna de dicionário weights e cash.
  • Portfólio: Portfolio(name="", tickers=None, weights=None, cash=0.0, time_range=None); passe tickers e um array-like plano weights alinhado a esses tickers.
  • Backtest: crie objetos portfolio.Portfolio para a alocação otimizada e cada benchmark; para um benchmark de peso igual, use pesos de 1 / len(tickers) e cash=0.0, depois chame backtest.portfolio_backtester(test_portfolio, returns_dict, risk_free_rate=0.0, test_method="historical", benchmark_portfolios=[...]).backtest_against_benchmarks(...).
  • Rebalanceamento: rebalance.rebalance_portfolio(...) requer que dataset_directory seja um caminho CSV, não um DataFrame. Chame re_optimize(...); ele retorna (results_dataframe, re_optimize_dates, cumulative_portfolio_value).
  • Modelos de configuração: ReturnsComputeSettings, ScenarioGenerationSettings, KDESettings, ApiSettings e CvarParameters.

Exemplos

  • "Construa o portfólio ótimo a partir do S&P 500": carregue preços, calcule retornos LOG, gere cenários GPU KDE, defina CvarParameters apenas comprado e totalmente investido, resolva com cuOpt e reporte pesos diversificados mais retorno/CVaR.
  • "Plote a fronteira eficiente": chame create_efficient_frontier(...), retorne results_df e mostre ou salve a figura conforme solicitado.
  • "Me dê pesos por aversão ao risco": expanda results_df["weights"] em uma tabela por ativo.
  • "Backteste contra peso igual": construa os objetos Portfolio otimizado e de peso igual, use o backtester cuFOLIO e reporte Sharpe, Sortino e drawdown máximo.
  • "Backteste rebalanceamento mensal": configure rebalance_portfolio com o gatilho de desvio acima e execute re_optimize(transaction_cost_factor=...).

Limitações

  • Requer uma GPU NVIDIA com cuOpt e cuML; solvers de CPU são intencionalmente proibidos.
  • Contêineres de avaliação apenas CPU ainda podem validar roteamento, manipulação de dados e comportamento de relatório, mas não podem produzir uma resolução cuOpt válida. Nesse caso, reporte o runtime GPU/cuOpt faltante explicitamente.
  • Dados de preços padrão são um snapshot histórico e podem omitir constituintes atuais.
  • O download do dataset na primeira execução depende de acesso à rede, a menos que o usuário forneça um CSV.

Solução de Problemas

  • CSV padrão ausente ou FileNotFoundError: explique que cuFOLIO buscará dados de mercado públicos com download_data("data/stock_data", datasets=["sp500"]); execute apenas após confirmação do usuário.
  • SolverError ou cp.CUOPT ausente: instale o extra CUDA correspondente ao host e verifique com python -c "import cvxpy as cp; print(hasattr(cp, 'CUOPT'), cp.installed_solvers())".
  • `Im

...

[truncado para tradução]

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

Habilidades Relacionadas