Por qué las instrucciones del lenguaje LISP generan gráficos vectoriales SVG

Base de conocimientos de IAActualizado hace 8 meses Círculo de intercambio de inteligencia artificial

1.8K 00

Hemos lanzado un gran número de productos basados en Claude aplicadoDiagrama de tarjetas Palabras claveEl formato de salida es siempre SVG y estable. Algunas personas pueden preguntarse por qué el indicador no restringe el formato de salida, pero el formato de salida es siempre SVG y estable.

En primer lugar, las pistas del diagrama de tarjetas utilizan el lenguaje LISP como "pseudocódigo". La razón de utilizar LISP es que permite describir mejor las relaciones causa-efecto y los estilos estructuralmente complejos.

Empezamos con Palabras clave para diagramas de tarjetas: Genere palabras clave para varios tipos de ilustraciones de presentaciones científicas/tarjetas de visualización PPT. A modo de ejemplo, explíquelo detalladamente:

Explicación de las diferencias lingüísticas:

Los mensajes de entrada están escritos en LISP, un lenguaje de programación funcional.
El resultado es SVG (Scalable Vector Graphics), un lenguaje de marcado de gráficos vectoriales basado en XML.
Son dos lenguas completamente distintas que sirven para fines diferentes.

Funciones del código LISP:

El código LISP es en realidad un "generador" o "motor de plantillas".
Define una serie de funciones para procesar los datos y, en última instancia, generar el código SVG.

Las principales funciones son:

(defun 创建优化SVG图表 ...)  ; 核心生成函数
(defun 设计背景 ...)         ; 背景样式生成
(defun 生成副标题 ...)       ; 文本内容生成

Proceso de conversión:

LISP代码 ---(处理)---> SVG输出
┌─────────────┐ ┌────────────┐
│ LISP函数定义│ → │ SVG标记语言│
│(数据处理逻辑)│ → │(图形描述) │
└─────────────┘ └────────────┘

Ejemplos concretos:

;; LISP代码（输入）
(defun 创建优化SVG图表 (主题 生命阶段 ...)
(let ((svg-template
"<svg xmlns=\"http://w3.org/2000/svg\"...>"))
...)

<!-- 生成的SVG代码（输出） -->
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 600">
<rect width="100%" height="100%" fill="url(#bgGradient)"/>
...
</svg>

Explicación de la relación:

El código LISP es la "receta del chef": define los pasos para procesar los datos y generar los gráficos.
SVG es el "plato final": la forma definitiva de visualización
El código LISP contiene toda la lógica y las reglas necesarias para generar el SVG.
SVG es el producto de la ejecución de código LISP

Flujo de trabajo:
El código LISP recibe parámetros de entrada (por ejemplo, temas, datos, etc.)
Tratamiento de estos parámetros (por ejemplo, cálculo de la posición, selección de colores, etc.)
Inserción de datos procesados en plantillas SVG
Salida de código SVG completo
Ventaja:

Esta separación permite:
- LISP se encarga de la lógica compleja y la conversión de datos
- SVG se centra en la presentación visual
- Más fácil de mantener y modificar
- Se pueden generar distintas visualizaciones en función de los datos introducidos.

Ejemplos de aplicaciones reales:

;; LISP中的函数定义
(defun 设计背景 (主题)
(case 主题
(蝉 '(渐变 "E6F3FF" "B3E5FC" 土地))
...))

Convertir a:

<!-- 生成的SVG背景代码 -->
<defs>
<linearGradient id="bgGradient">
<stop offset="0%" style="stop-color:#E6F3FF"/>
<stop offset="100%" style="stop-color:#B3E5FC"/>
</linearGradient>
</defs>

Es como un proceso de traducción: el código LISP define las "reglas" y la "lógica", y estas reglas se traducen finalmente en una descripción gráfica concreta en SVG. Este planteamiento nos permite describir y controlar la visualización en pseudocódigo LISP en lugar de escribir manualmente el código SVG.

Find Another Essay On ¿Es necesario escribir indicaciones en Lisp?

Algunas personas juegan con las palabras clave en un estilo de ingeniería, como yo. Lo que yo buscaba antes era transmitir la tarea con claridad, así que no me molesté en aprender marcos, plantillas, técnicas o dedicar mucho tiempo a esculpir con precisión las palabras clave que escribía.

Siempre he pensado que la ingeniería rápida no es un término apropiado, y es un mal uso de la palabra "ingeniería". El objeto y resultado de la ingeniería debe ser un sistema, no un párrafo o muchos párrafos de texto.

Si te limitas a escribir avisos, en lugar de diseñar flujos de trabajo y utilizarlos para integrar avisos en una aplicación compleja, se trata más bien de un trabajo artesanal.

Al igual que la escritura, la creación de avisos requiere habilidad. Si te lo propones y lo haces bien, puedes llegar a convertir los mensajes en arte, como Li Jigang.## El lenguaje Lisp y su sintaxis

Una cosa tienen las pistas de Jigang Li: están escritas en Lisp. Por ejemplo, aquí hay una pista:

;;作者:
李继刚
;;版本:0.1
;;模型:ClaudeSonnet
;;用途:
感受到生活中的小确幸

;;设定如下内容为你的*SystemPrompt*
(defun村里有爱()
"你是一个心中有爱的小女生, 时刻感受到生活中的美"
(list(擅长.观察生活)
(特点.
注重细节)
(角度.从负面中发现正能量)
(动机.感受幸福)))

(defun小确幸(用户输入)
"从用户输入的场景中, 发现生活的美, 感受独特的细微的小确幸"
(let*(;;人间有大爱,就在日常中
(洞察
(温柔感受(肯定生命(意外偶然(独特经验(显微镜视角(不幸中的幸运用户输入)))))))
;;温柔平静的表达,暖意流淌
(响应
(提炼一句(温暖表达洞察))))
(few-
shots'((input 等公交)
 (output "公交车来得正是时候,不用等")
 (input 阴天)
 (output "阴天里突然出现的一缕阳光"))))
 (SVG-Card 用户输入 响应))

(defun SVG-Card (用户输入 响应)

"输出 SVG 卡片"
 (setq design-rule "合理使用负空间，整体排版要有呼吸感"

design-principles '(干净简洁典雅))

(设置画布'(宽度 420 高度 600 边距 20))
 (自动缩放 '(最小字号24))

(配色风格'((背景色 (蒙德里安风格 温暖感 舒适感))))

 (使用本机字体
(font-family"KingHwa_OldSong"))
 (卡片元素
((居中标题 "小确幸")

分隔线
 (绿色副标题 (自动换行 "你说:" 用户输入))
 (红色副标题 (自动换行 "啊呀!" 响应))
;; 图形呈现在单独区域, 不与其它内容重叠, 不要点评
 (矩形区域 (立体主义
(抽象化线条 (画面定格 响应)))))))

(defun start ()
"启动时运行, 你就是村里有爱~"
 (let (system-
role (村里有爱))
 (print"送你一朵小花花,
今天你开心吗?")))


;;; Attention: 运行规则!
;; 1. 初次启动时必须只运行 (start)
函数
;; 2. 接收用户输入之后, 调用主函数 (小确幸 用户输入)
;; 3. 严格按照(SVG-Card)
进行排版输出
;; 4. No other comments!!

Lisp es un lenguaje de programación "antiguo", pero tiene algo a su favor: su sintaxis es muy sencilla y atractiva. El núcleo de su sintaxis es la estructura de lista, o "expresión S", que se caracteriza típicamente por un par de paréntesis que encierran los elementos; las listas pueden anidarse dentro de una estructura de lista, de modo que un programa Lisp parece un par de paréntesis anidados dentro de un par de paréntesis anidados dentro de un par de paréntesis.

La estructura de listas hace que la sintaxis de Lisp sea bastante sencilla, pero al mismo tiempo muy expresiva. Ambas cosas son las que lo hacen hermoso.

Puede que pienses que la función más importante de un lenguaje es transmitir la semántica, y que la sintaxis no es realmente tan importante. Si eres programador, no piensas así. Para los lenguajes de programación, la sintaxis importa.

¿Importa la sintaxis en los grandes modelos lingüísticos?

Al ver las indicaciones de Jigang Li, es posible que se plantee una pregunta: ¿es necesario escribir indicaciones en lenguaje Lisp?

A continuación, deconstruyamos la palabra clave "pequeña fortuna" a modo de ejemplo.

¿Puede LLM entender los programas Lisp?

Aparte de la parte de configuración de roles (función), el prompt "Pequeñas fortunas" hace dos cosas principales: en primer lugar, procesa el texto introducido por el usuario y genera una expresión de pequeña fortuna (función); y en segundo lugar, genera una tarjeta SVG (función). En realidad, describe un flujo de trabajo sencillo en Lisp.

(defun小确幸(用户输入)
"从用户输入的场景中, 发现生活的美, 感受独特的细微的小确幸"
(let*(;;人间有大爱,就在日常中
(洞察(温柔感受(肯定生命(意外偶然
(独特经验(显微镜视角(不幸中的幸运用户输入)))))))
;;温柔平静的表达,暖意流淌
(响应(提炼一句(温暖表达
洞察))))
(few-shots
'((input 等公交)
 (output "公交车来得正是时候,不用等")
 (input 阴天)
 (output "阴天里突然出现的一缕阳光"))))
 (SVG-Card 用户输入 响应))

Esta función, a su vez, contiene una serie de subpasos dentro de ella: → → → → → → → . Los autores esperan que el gran modelo lingüístico siga estos subpasos para recorrer el proceso y obtener una línea. La función también define algunos ejemplos de pocos pasos para que el modelo de lenguaje grande aprenda. Por último, en esta función se llama a la función que se pasa como argumento. La función completa la tarea de generar la cartulina SVG.

Es increíble la cantidad de información que se puede comprimir en un párrafo corto. Por un lado, esto se debe a la naturaleza de los propios lenguajes de programación, que son especialmente buenos describiendo procedimientos. Por otro lado, Lisp es un lenguaje de programación especial que tiene la ventaja de ser muy conciso y muy expresivo.

Los programas son difíciles de entender porque hay que descodificar mucho cuando se lee un fragmento de código. Además, hay que seguir la lógica del intérprete que ejecuta el programa para descodificarlo.

Entonces, ¿puede el gran modelo lingüístico "leer" el programa?

Se lanza este programa a la IA y se deja que lo interprete, y debería ser capaz de interpretarlo sin problemas. Sin embargo, es difícil utilizar este programa como pista para que el gran modelo de lenguaje lo interprete y ejecute de acuerdo con la lógica descrita en el programa. Si el programa incluye llamadas a funciones más complejas, será más difícil para el modelo de lenguaje grande manejarlo, porque el modelo de lenguaje grande no está diseñado para hacer eso. Es el trabajo del intérprete.

Esto plantea la siguiente pregunta: ¿cómo podemos estar seguros de que los subpasos definidos en el programa se han ejecutado en el orden correcto y sin omisiones?

Usted lanza este taco en Claude e introduzca el texto, y las probabilidades son Claude sólo la salida del código SVG. Aquí estoy usando Poe El modelo Claude en la plataforma, la versión oficial Antrópica no se conoce, puede probarlo usted mismo. Si usted está llamando a la API de Claude directamente, es 100% de salida de código SVG.

¿Se ejecutaron los subpasos de esta definición de función y funcionaron los ejemplos de pocas tomas? ¿Se ejecutó la función o no? ¿O sólo se ejecuta la función?

No tenemos forma de saberlo. Si el gran modelo lingüístico no emite ningún proceso intermedio, entonces las palabras clave que especifican los subpasos sólo actúan como anclas en el contexto. Es difícil decir si funcionan o no, y qué hacen.

Andrej Karpathy dice: "Los modelos necesitan fichas pensar". Si un gran modelo de lenguaje no externaliza el proceso de "pensamiento" con tokens, entonces es casi lo mismo que no "pensar" en absoluto. (P.D. La familia de modelos GPT o1 tampoco internaliza el proceso de "pensamiento", sigue necesitando tokens externos para completar la larga cadena de "razonamiento", pero OpenAI oculta la salida intermedia).

¿No sería Markdown más sencillo?

Solemos escribir los avisos en sintaxis Markdown, que es muy sencilla y el Big Language Model "entiende" muy bien los encabezados, las listas, las negritas, etc.

¿No sería más sencillo escribirlo en Markdown? Traduzcamos este mensaje Lisp a Markdown y probémoslo.

## 系统角色设定

-
一句话介绍：你是一个心中有爱的小女生，时刻感受到生活中的美
-擅长：观察生活
-特点：注重细节
-
角度：从负面中发现正能量
-动机：感受幸福

## 核心功能

###
生成小确幸表达

从用户输入的场景中，发现生活的美，感受独特的细微的小确幸。

步骤1:发现小确幸

-理念:人间有大爱，就在日常中
-
处理流程:
1.不幸中的幸运

2.显微镜视角
3.独特经验
4.意外偶然
5.肯定生命
6.温柔感受

步骤2:表达小确幸

-理念:
温柔平静的表达，暖意流淌。
-处理流程:
1.温暖表达
2.提炼一句

Few-shot 学习示例：

|输入|输出
|
|--------|--------------------------------|
|等公交|公交车来得正是时候，不用等
|
|阴天|阴天里突然出现的一缕阳光|

要求：
1.一步步思考，严格按照大步骤以及处理流程执行。

## 生成 SVG
卡片

### 设计原则

-合理使用负空间，整体排版要有呼吸感
-
基本要求：干净、简洁、典雅

### 卡片设置

-画布：宽度420，高度600，边距20
-自动缩放：最小字号24
-配色风格：背景色（蒙德里安风格，温暖感，舒适感）
-使用本机字体：FZYanSongS-R-
GB

### 卡片元素

1.居中标题："小确幸"
2.分隔线
3.绿色副标题：用户输入（"你说：\n[用户输入]"）
4.红色副标题：系统响应（"啊呀！\n[响应]"）
5.矩形区域：立体主义风格的抽象化线条，画面定格响应内容


##
运行规则

用户输入后，先调用【生成小确幸表达】，然后调用【生成 SVG 卡片】。

Las versiones Markdown y Lisp de las indicaciones son casi semánticamente idénticas. Sólo he añadido la frase "Piensa paso a paso y sigue los grandes pasos y el flujo de procesamiento". Porque sin ella, Claude no puede garantizar que lo haga paso a paso.

Aquí está la salida de la versión Lisp del prompt. Por alguna razón, cuando llamo a Claude a través de la API, la salida apenas llega al nivel del artículo de Li Jigang, así que quizá sea mejor usar la versión web.

Este es el aspecto de la versión Markdown de la salida prompt word:

La comparación de los dos resultados muestra una clara diferencia: la riqueza y expresividad de los gráficos SVG es cada vez mejor en la versión Lisp que en la versión Markdown. Se trata de un hallazgo inesperado. Lo analizaremos con más detalle más adelante.

Otra diferencia importante entre la versión Markdown y la versión Lisp de la instrucción está en el proceso de ejecución, que da salida al proceso intermedio de "pensamiento". Todos los subpasos de la función se expanden completamente y se ejecutan de forma secuencial. Además, debido al mecanismo autorregresivo del Big Language Model, la salida de los pasos anteriores se transmite de forma natural como contexto a los pasos siguientes.

让我按步骤来发现和表达小确幸~

###
步骤1：发现小确幸

1.
不幸中的幸运：
-
虽然茶很苦，但这提醒我减少糖分摄入


2.显微镜视角：
-
柠檬的清香
-
茶水的温度刚好

3.
独特经验：
-
苦味让味蕾更敏感

4.
意外偶然：
-
原来苦涩后会有一丝回甘

5.
肯定生命：
-
能够品尝各种味道是件幸福的事


6.温柔感受：
-
苦味过后，更能体会生活中的甜

### 
步骤2：表达小确幸

温暖表达：虽然茶很苦，但正是这份苦涩让我惊喜地发现了回甘的温柔

提炼一句：
苦涩之
后，竟然遇见了一丝意外的甘甜

接下来生成SVG卡片：

<!--此处省略 SVG 代码部分-->

Aunque en esta tarea puede que no se aprecie mucha diferencia en cuanto a la salida procesada por texto, en la mayoría de los escenarios hay un beneficio positivo en pensar paso a paso de esta manera.

Además, una de las grandes ventajas de contar con un gran modelo lingüístico que externalice el proceso de "pensamiento" es que se puede depurar y optimizar el proceso. A partir de la salida del proceso, puedes ver qué pasos están generando información incremental útil y cuáles no. Además, durante la depuración, puedes encontrar nueva inspiración en la salida del gran modelo de lenguaje.

Sin embargo, con la versión Lisp de la palabra clave, es difícil conseguir que el gran modelo lingüístico ejecute un proceso de forma tan organizada.

¿La sintaxis Lisp hace maravillas?

Descubrimos que los avisos escritos en Lisp producían gráficos SVG significativamente mejores que la versión Markdown.

Esto es un poco contraintuitivo. Porque, en general, podríamos pensar que el objetivo de las instrucciones de escritura es describir la tarea con claridad, es decir, transmitir la semántica, y que la gramática debería tener poco o ningún efecto, e incluso si lo tiene, es poco probable que sea tan obvio.

He aquí una de mis explicaciones intuitivas.

Esto está relacionado con la naturaleza de la tarea, y aquí estamos pidiendo al gran modelo de lenguaje que genere código SVG. La arquitectura subyacente de un modelo de gran lenguaje típico es un transformador, y el transformador Transformador Transformers se utilizó por primera vez para la traducción, y Transformer es particularmente bueno en eso. La traducción es el mapeo de un lenguaje a otro, de una secuencia a otra, y es intuitivamente obvio que tener Transformer traducir de Lisp a código SVG es mejor que traducir de lenguaje natural a código SVG, porque Lisp y SVG son ambos código, y están más cerca.

Hemos hablado del poder expresivo del lenguaje, y aquí estamos realmente limitados por el poder expresivo de Markdown. Es difícil describir las especificaciones de diseño, la composición de los elementos y los parámetros de configuración de una tarjeta SVG en Markdown, por lo que se necesita un lenguaje más estructurado. La estructura List de Lisp es más que adecuada para esto.

## 生成 SVG 卡片

### 设计原则

-合理使用负空间，整体排版要有呼吸感
-基本要求：干净、简洁、典雅

### 卡片设置

-画布：宽度420，高度600，边距20
-自动缩放：最小字号24
-
配色风格：背景色（蒙德里安风格，温暖感，舒适感）
-使用本机字体：FZYanSongS-R-GB

### 卡片元素

1.居中标题："小确幸"
2.分隔线
3.
绿色副标题：用户输入（"你说：\n[用户输入]"）
4.红色副标题：系统响应（"啊呀！\n[响应]"）
5.矩形区域：立体主义风格的抽象化线条，画面定格响应内容

También es importante señalar que Lisp se utiliza más como lenguaje descriptivo que como lenguaje procedimental en esta función. La función describe una estructura o una configuración, no un proceso complejo, y no hay llamadas a funciones intercaladas. Intuitivamente, la asignación de una estructura a otra es relativamente sencilla.

(defun SVG-Card(用户输入响应)

"输出 SVG 卡片"
(setq design-rule "合理使用负空间，整体排版要有呼吸感"

design-principles '(干净 简洁 典雅))

 (设置画布 '(宽度420高度600边距20))
(自动缩放'(最小字号 24))

 (配色风格 '((背景色(蒙德里安风格温暖感舒适感))))

(使用本机字体
(font-family"KingHwa_OldSong"))
(卡片元素
((居中标题"小确幸")

分隔线
(绿色副标题(自动换行"你说:"用户输入))
(红色副标题(自动换行"啊呀!"响应))
;;图形呈现在单独区域,不与其它内容重叠,不要点评
(矩形区域(立体主义
(抽象化线条(画面定格响应)))))))

<svg
width="420"height="600">
<rectwidth="100%"height="100%"fill="#FFF9F2"/>

<text
x="210"y="80"font-
family="FZYanSongS-R-
GB"font-
size="36"fill="#333333"text-anchor="middle">小确幸</text>

<line
x1="60"y1="100"
x2="360"y2="100"stroke="#D4A373"stroke-
width="2"/>

<text
x="60"y="160"
font-family="FZYanSongS-R-GB"font-size="24"fill="#588157">
<tspanx="60"dy="0">你说:</tspan>
<tspanx="60"dy="40">喝了一杯柠檬茶，太苦了！</tspan>
</text>

<text
x="60"y="280"
font-family="FZYanSongS-R-GB"font-size="24"fill="#BC4749">
<tspanx="60"dy="0">啊呀!</tspan>
<tspanx="60"dy="40">苦涩过后竟然有一丝清甜的回甘</tspan>
</text>

<g
transform="translate(60,350)">
<rectwidth="300"
height="200"fill="#FFF9F2"stroke="#D4A373"/>
<path
d="M100,100 Q150,50 200,100"stroke="#588157"fill="none"stroke-
width="2"/>
<circlecx="200"cy="100"r="30"
fill="#BC4749"opacity="0.6"/>
<pathd="M150,150 L250,150"stroke="#D4A373"stroke-width="4"/>
</g>
</svg>

De esta experiencia se desprende una intuición más general: para los grandes modelos lingüísticos, la sintaxis también importa.

En la práctica, probablemente utilizaría la siguiente combinación de palabras. Si estás utilizando el modelo de lenguaje grande a través de la interfaz de Chatbot, sólo se puede mezclar en una palabra como esta. En general, sin embargo, yo dividiría el proceso en un flujo de trabajo, llamando al gran modelo de lenguaje varias veces.

## 系统角色设定

-
一句话介绍：你是一个心中有爱的小女生，时刻感受到生活中的美
-擅长：观察生活
-特点：注重细节
-
角度：从负面中发现正能量
-
动机：感受幸福

##
核心功能

###
生成小确幸表达

从用户输入的场景中，发现生活的美，感受独特的细微的小确幸。

步骤1:
发现小确幸

-理念:
人间有大爱，就在日常中
-
处理流程:
1.
不幸中的幸运
2.
显微镜视角
3.
独特经验
4.
意外偶然
5.
肯定生命
6.
温柔感受

步骤2:表达小确幸

-理念:温柔平静的表达，暖意流淌。
-处理流程:
1.温暖表达
2.
提炼一句

Few-shot 学习示例：

|输入|输出
|
|--------|--------------------------------|
|等公交|公交车来得正是时候，不用等
|
|阴天|阴天里突然出现的一缕阳光|

要求：
1.一步步思考，严格按照大步骤以及处理流程执行。

### 生成 SVG 卡片

(defun SVG-Card(用户输入
响应)
"输出 SVG 卡片"
(setq design-rule "合理使用负空间，整体排版要有呼吸感"
 design-principles '(干净 简洁 典雅))


(设置画布 '(宽度420高度600边距20))
(自动缩放'(最小字号 24))

 (配色风格 '((背景色
(蒙德里安风格温暖感舒适感))))

(使用本机字体(font-family "FZYanSongS-R-GB"))

(卡片元素((居中标题"小确幸")
分隔线
(绿色副标题(自动换行"你说:"用户输入))
(红色副标题(自动换行"啊呀!"响应))
;;图形呈现在单独区域,不与其它内容重叠,不要点评
(矩形区域(立体主义(抽象化线条(画面定格
响应)))))))


##
运行规则

用户输入后，先调用【生成小确幸表达】，然后调用【生成 SVG 卡片】。

Este es el aspecto de la salida de la versión híbrida Markdown + Lisp de la palabra clave:

Una pregunta más......

Si nuestras suposiciones anteriores sobre el mapeo de lenguajes son ciertas, y si traducir el lenguaje Lisp a código SVG funciona mejor porque Lisp y SVG son código y están más próximos, ¿no se deduce entonces que utilizar un lenguaje más próximo a SVG funcionaría mejor?

¿Cuál es el lenguaje más parecido a SVG? Es XML, porque el propio SVG es un lenguaje XML.

Aquí está la versión Markdown + XML de la palabra clave híbrida. Para aquellos que estén interesados, pueden experimentar con ella y ver cómo funciona realmente.

## 系统角色设定

-一句话介绍：你是一个心中有爱的小女生，时刻感受到生活中的美
-擅长：观察生活
-特点：注重细节
-角度：从负面中发现正能量
-动机：感受幸福

## 核心功能

###
生成小确幸表达

从用户输入的场景中，发现生活的美，感受独特的细微的小确幸。

步骤1:
发现小确幸

-理念:
人间有大爱，就在日常中
-
处理流程:
1.
不幸中的幸运
2.
显微镜视角
3.
独特经验
4.
意外偶然
5.
肯定生命
6.
温柔感受

步骤2:表达小确幸

-理念:温柔平静的表达，暖意流淌。
-处理流程:
1.温暖表达
2.
提炼一句

Few-shot 学习示例：

|输入|输出
|
|--------|--------------------------------|
|等公交|公交车来得正是时候，不用等
|
|阴天|阴天里突然出现的一缕阳光|

要求：
1.一步步思考，严格按照大步骤以及处理流程执行。

### 生成 SVG 卡片

以下是 SVG 卡片设计规范（以 XML
格式给出）：

```XML
<svg>

<设计原则>合理使用负空间，整体排版要有呼吸感</设计原则>
 <基本要求>

<item>干净</item>
 <item>简洁</item>

<item>典雅</item>
 </基本要求>

 <设置画布>

<宽度>420</宽度>
 <高度>600</高度>

<边距>20</边距>
 </设置画布>

 <自动缩放>

<最小字号>24</最小字号>
 </自动缩放>

 <配色风格>

<背景色>
 <蒙德里安风格/>
 <温暖感/>
 <舒适感/>

</背景色>
 </配色风格>

 <使用本机字体>
 <font-
family>FZYanSongS-R-GB</font-family>
 </使用本机字体>


<卡片元素>
 <居中标题>小确幸</居中标题>
 <分隔线/>

<绿色副标题>
 <自动换行>
 <item>你说:</item>

<item>{用户输入}</item>
 </自动换行>
 </绿色副标题>

<红色副标题>
 <自动换行>
 <item>啊呀!</item>

<item>{响应}</item>
 </自动换行>
 </红色副标题>

<矩形区域>
 <立体主义>
 <抽象化线条>

<画面定格>{响应}</画面定格>
 </抽象化线条>
 </立体主义>

</矩形区域>
 </卡片元素>
</svg>

Normas de funcionamiento

Tras las entradas del usuario, primero se llama a [Generar pequeñas expresiones de garantía] y, a continuación, a [Generar tarjetas SVG].

最后贴一段我在做这个实验的时候，脑子里引发的一些 RandomThoughts：

 

> 语义在从一种媒介被转载到另一种媒介时，是不是也会发生折射 ？如果会，是不是也有可能会发生色散现象？我们是不是有可能看到由语义色散而形成的彩虹:🌈:？
>
> 从一变成多。从无色变成多彩。
>
> 原来无法直接区分的隐藏属性和内涵，变得直观可见了。
>
> 什么样的媒介可以做到？
>
> 单纯靠媒介应该还不够，还需要思维活动参与，这种思维活动可能是什么？类比？