Pourquoi les invites de langage LISP génèrent-elles des graphiques vectoriels SVG ?

Base de connaissances sur l'IAMise à jour il y a 9 mois Cercle de partage de l'IA

2.4K 00

Nous avons mis sur le marché un grand nombre de produits basés sur Claude appliquéeDiagramme de la carte Mots clésLe format de sortie est toujours SVG et stable. Certaines personnes peuvent se demander pourquoi l'invite ne contraint pas le format de sortie, mais le format de sortie est toujours SVG et stable.

Premièrement, les indices des diagrammes de cartes utilisent le langage LISP comme "pseudo-code", la raison de l'utilisation du LISP étant qu'il peut mieux décrire la complexité structurelle des relations de cause à effet et des schémas.

Nous avons commencé par Mots clés pour les diagrammes de cartes : générer des mots clés pour différents types d'illustrations de présentations scientifiques/de cartes de visualisation TP. Expliquez-le en détail à titre d'exemple :

Les différences linguistiques expliquées :

Les invites de saisie sont écrites en LISP, un langage de programmation fonctionnel.
Le résultat est le SVG (Scalable Vector Graphics), un langage de balisage vectoriel basé sur XML.
Il s'agit de deux langues complètement différentes qui servent des objectifs différents.

Rôles du code LISP :

Le code LISP est en fait un "générateur" ou un "moteur de modèle".
Il définit une série de fonctions pour traiter les données et finalement générer le code SVG.

Les principales fonctions sont les suivantes

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

Processus de conversion :

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

Exemples concrets :

;; 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>

Explication de la relation :

Le code LISP est la "recette du chef" : il définit les étapes du traitement des données et de la génération des graphiques.
SVG est le "dernier plat" : la forme finale de la visualisation
Le code LISP contient toute la logique et les règles nécessaires pour générer le SVG.
SVG est le produit de l'exécution d'un code LISP

Flux de travail :
Le code LISP reçoit des paramètres d'entrée (par exemple, des thèmes, des données, etc.).
Traitement de ces paramètres (par exemple, calcul de la position, sélection des couleurs, etc.)
Insérer des données traitées dans des modèles SVG
Sortie du code SVG complet
Avantage :

Cette séparation permet :
- LISP gère la logique complexe et la conversion des données
- SVG se concentre sur la présentation visuelle
- Plus facile à maintenir et à modifier
- Différentes visualisations peuvent être générées sur la base de différentes données.

Exemples d'applications réelles :

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

Convertir en :

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

Il s'agit d'un processus de traduction : le code LISP définit les "règles" et la "logique", et ces règles sont finalement traduites en une description graphique concrète dans le SVG. Cette approche nous permet de décrire et de contrôler la visualisation en pseudo-code LISP plutôt que d'écrire manuellement le code SVG.

Find Another Essay On Is it necessary to write prompts in Lisp ?

Certaines personnes, comme moi, jouent avec les mots indicateurs dans un style d'ingénierie. Ce que je cherchais avant, c'était de faire passer la tâche clairement, alors je n'ai pas pris la peine d'apprendre des cadres, des modèles, des techniques, ou de passer beaucoup de temps à sculpter finement les mots indicateurs que j'écrivais.

J'ai toujours pensé que le terme "prompt engineering" n'était pas approprié et qu'il s'agissait d'une mauvaise utilisation du mot "engineering". L'objet et le résultat de l'ingénierie devraient être un système, et non un ou plusieurs paragraphes de texte.

Si vous vous contentez de rédiger des messages-guides, plutôt que de concevoir un flux de travail et de l'utiliser pour intégrer des messages-guides dans une application complexe, il s'agit alors davantage d'un métier.

Tout comme l'écriture, l'élaboration d'un message-guide requiert un certain savoir-faire. Si vous vous lancez, et si vous jouez bien le jeu, vous pourriez même transformer les messages en art, comme Li Jigang.## Le langage Lisp et sa syntaxe

Les questions de Jigang Li ont ceci de particulier qu'elles sont écrites en Lisp. Par exemple, voici un indice :

;;作者:
李继刚
;;版本: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 est un "vieux" langage de programmation, et il a un avantage : sa syntaxe est très simple et très belle. Le cœur de sa syntaxe est la structure de liste, ou "expression S", qui est typiquement caractérisée par une paire de parenthèses entourant les éléments ; les listes peuvent être imbriquées dans une structure de liste, de sorte qu'un programme Lisp ressemble à une paire de parenthèses imbriquées dans une paire de parenthèses imbriquées dans une paire de parenthèses.

La structure de liste rend la syntaxe de Lisp assez simple, mais en même temps très expressive. C'est la combinaison des deux qui en fait la beauté.

On pourrait penser que la fonction la plus importante d'un langage est de transmettre la sémantique, et que la syntaxe n'est pas vraiment importante. Si vous êtes programmeur, vous n'êtes pas de cet avis. Pour les langages de programmation, la syntaxe est importante.

La syntaxe est-elle importante pour les grands modèles de langage ?

En regardant les messages-guides de Jigang Li, vous vous posez peut-être la question suivante : est-il nécessaire d'écrire des messages-guides en langage Lisp ?

Décortiquons ensuite le mot clé "petite fortune" à titre d'exemple.

LLM peut-il comprendre les programmes Lisp ?

Outre la partie relative à la définition des rôles (fonction), l'invite "Petites fortunes" a deux fonctions principales : premièrement, elle traite le texte saisi par l'utilisateur et génère une expression de petite fortune (fonction) ; deuxièmement, elle génère une carte SVG (fonction). Il s'agit en fait de la description d'un flux de travail simple en Lisp.

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

Cette fonction contient à son tour une série de sous-étapes : → → → → → → → . Les auteurs s'attendent à ce que le grand modèle de langage suive ces sous-étapes pour parcourir le processus et produire une ligne. La fonction définit également quelques exemples ponctuels que le grand modèle de langage doit apprendre. Enfin, la fonction est appelée dans cette fonction, transmise en tant qu'argument. La fonction termine la tâche de génération de la carte SVG.

Il est étonnant de voir combien d'informations sont comprimées dans un court paragraphe ! D'une part, cela est dû à la nature même des langages de programmation, qui sont particulièrement aptes à décrire des procédures. D'autre part, Lisp est un langage de programmation particulier qui a l'avantage d'être très concis et très expressif.

Les programmes sont difficiles à comprendre parce que vous devez faire beaucoup de décodage lorsque vous lisez un morceau de code. De plus, vous devez suivre la logique de l'interprète qui exécute le programme pour décoder le code.

Le grand modèle linguistique peut-il donc "lire" le programme ?

Vous lancez ce programme à l'IA et la laissez l'interpréter, et elle devrait être capable de l'interpréter très bien. Toutefois, il est difficile d'utiliser ce programme pour que le grand modèle linguistique l'interprète et l'exécute conformément à la logique décrite dans le programme. Si le programme implique des appels de fonctions plus complexes, il sera plus difficile pour le grand modèle de langage de le gérer, car le grand modèle de langage n'est pas conçu pour cela. C'est le travail de l'interprète.

Cela soulève la question suivante : comment pouvons-nous être sûrs que les sous-étapes définies dans le programme ont été exécutées dans l'ordre correct et sans omission ?

Vous lancez cette queue à Claude et entrez le texte, et il y a de fortes chances que Claude produise simplement le code SVG. Ici, j'utilise Poe Le modèle Claude sur la plateforme, la version officielle d'Anthropic n'est pas connue, vous pouvez la tester vous-même. Si vous appelez l'API Claude directement, elle produit du code SVG à 100%.

Les sous-étapes de la définition de cette fonction ont-elles été exécutées et les quelques exemples fonctionnent-ils ? La fonction a-t-elle été exécutée ou non ? Ou bien la fonction est-elle simplement exécutée ?

Nous n'avons aucun moyen de le savoir. Si le grand modèle linguistique ne produit aucun processus intermédiaire, les mots-clés qui spécifient les sous-étapes ne servent que de points d'ancrage dans le contexte. Il est difficile de dire s'ils fonctionnent ou non, et ce qu'ils font.

Andrej Karpathy déclare : "Les modèles ont besoin de jetons penser". Si un grand modèle de langage n'externalise pas le processus de "pensée" avec des jetons, alors c'est presque la même chose que de ne pas "penser" du tout. (PS. La famille de modèles GPT o1 n'internalise pas non plus le processus de "pensée", elle a toujours besoin de jetons externes pour compléter la longue chaîne de "raisonnement", mais OpenAI cache les résultats intermédiaires).

Markdown ne serait-il pas plus simple ?

Nous écrivons généralement les messages-guides en syntaxe Markdown, qui est très simple et le Big Language Model "comprend" très bien les titres, les listes, les caractères gras, etc.

Ne serait-il pas plus simple d'écrire l'invite en Markdown ? Traduisons cette invite Lisp en Markdown et essayons-la.

## 系统角色设定

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

## 核心功能

###
生成小确幸表达

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

步骤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 卡片】。

Les versions Markdown et Lisp des invites sont presque identiques sur le plan sémantique. J'ai juste ajouté la phrase "Pensez étape par étape, et suivez les grandes étapes et le flux de traitement". Parce que sans cette phrase, Claude ne peut pas garantir qu'il le fera étape par étape.

Voici le résultat de la version Lisp de l'invite. Pour une raison quelconque, lorsque j'appelle Claude via l'API, le résultat n'est pas du tout à la hauteur de l'article de Li Jigang, il est donc préférable d'utiliser la version web.

Voici à quoi ressemble la version Markdown de la sortie du mot-guide :

La comparaison des deux résultats montre une nette différence : la richesse et l'expressivité des graphiques SVG sont régulièrement meilleures dans la version Lisp que dans la version Markdown. Il s'agit là d'une découverte inattendue ! Nous l'étudierons plus en détail ultérieurement.

Une autre différence importante entre la version Markdown et la version Lisp de l'invite réside dans le processus d'exécution, qui produit le processus de "réflexion" intermédiaire. Toutes les sous-étapes de la fonction sont entièrement développées et exécutées de manière séquentielle. De plus, en raison du mécanisme autorégressif du Big Language Model, la sortie des étapes précédentes est naturellement transmise en tant que contexte aux étapes suivantes.

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

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

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


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

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

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

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


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

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

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

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

接下来生成SVG卡片：

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

Même si, dans cette tâche, vous ne verrez peut-être pas une grande différence en termes de résultat du traitement de texte, dans la plupart des scénarios, il y a un avantage à penser étape par étape de cette manière.

En outre, l'un des grands avantages de l'externalisation du processus de "réflexion" à l'aide d'un grand modèle linguistique est qu'il permet de déboguer et d'optimiser le processus. À partir des résultats du processus, vous pouvez voir quelles étapes génèrent des informations incrémentielles utiles et lesquelles ne le font pas. En outre, lors du débogage, vous pouvez trouver une nouvelle inspiration dans les résultats du grand modèle linguistique.

Cependant, avec la version Lisp du mot de repère, il est difficile de faire en sorte que le grand modèle linguistique exécute un processus d'une manière aussi organisée.

La syntaxe Lisp fait-elle des merveilles ?

Nous avons constaté que les messages écrits en Lisp produisaient des graphiques SVG de bien meilleure qualité que la version Markdown.

C'est un peu contre-intuitif. En effet, en général, on pourrait penser que l'objectif des messages d'encouragement à la rédaction est de décrire clairement la tâche, c'est-à-dire de transmettre la sémantique, et que la grammaire ne devrait avoir que peu ou pas d'effet, et même si c'est le cas, il est peu probable que ce soit aussi évident.

Voici une de mes explications intuitives.

Ceci est lié à la nature de la tâche, et ici nous demandons au grand modèle de langage de générer du code SVG. L'architecture sous-jacente d'un grand modèle de langage typique est un transformateur, et la fonction Transformateur Les transformateurs ont d'abord été utilisés pour la traduction, et Transformer est particulièrement doué pour cela. La traduction consiste à passer d'un langage à un autre, d'une séquence à une autre, et il est intuitivement évident qu'il est préférable que Transformer traduise du code Lisp au code SVG plutôt que du langage naturel au code SVG, parce que Lisp et SVG sont tous deux du code, et qu'ils sont plus proches l'un de l'autre.

Nous avons parlé du pouvoir d'expression du langage, et ici nous sommes vraiment limités par le pouvoir d'expression de Markdown. Il est difficile de décrire les spécifications de conception, la composition des éléments et les paramètres de configuration d'une carte SVG en Markdown, vous avez donc besoin d'un langage plus structuré. La structure List de Lisp est plus que suffisante pour faire le travail.

## 生成 SVG 卡片

### 设计原则

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

### 卡片设置

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

### 卡片元素

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

Il est également important de noter que Lisp est utilisé davantage comme un langage descriptif que comme un langage procédural dans cette fonction. La fonction décrit une structure ou une configuration, et non un processus complexe, et il n'y a pas d'appels de fonction entrelacés. Intuitivement, le passage d'une structure à une autre est relativement simple.

(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>

Une intuition plus générale peut être tirée de cette expérience : pour les grands modèles de langage, la syntaxe a aussi son importance.

En pratique, j'utiliserais probablement la combinaison suivante de mots-guides. Si vous utilisez le modèle linguistique global par l'intermédiaire de l'interface du Chatbot, il ne peut être mélangé qu'en un seul mot-guide comme celui-ci. En général, cependant, je décomposerais le processus en un flux de travail, en appelant le grand modèle linguistique plusieurs fois.

## 系统角色设定

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

##
核心功能

###
生成小确幸表达

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

步骤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 卡片】。

Voici à quoi ressemble la sortie de la version hybride Markdown + Lisp du mot-guide :

Encore une question......

Si nos hypothèses précédentes sur le mappage des langues se vérifient, et si la traduction du langage Lisp en code SVG fonctionne mieux parce que Lisp et SVG sont à la fois du code et plus proches l'un de l'autre, ne faut-il pas en déduire que l'utilisation d'un langage plus proche de SVG donnerait de meilleurs résultats ?

Quel est le langage le plus proche du SVG ? C'est le XML, car le SVG lui-même est un langage XML.

Voici la version Markdown + XML du mot de repère hybride. Pour ceux qui sont intéressés, vous pouvez l'expérimenter et voir comment il fonctionne réellement.

## 系统角色设定

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

## 核心功能

###
生成小确幸表达

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

步骤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>

Règles de fonctionnement

Après les entrées de l'utilisateur, [Générer de petites expressions de caution] est appelé en premier, puis [Générer des cartes SVG].

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

 

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