Warum LISP-Sprachaufforderungen SVG-Vektorgrafiken erzeugen

Wir haben eine große Anzahl von Produkten auf der Grundlage von Claude angewandtKarte Diagramm StichwortwörterDas Ausgabeformat ist immer SVG und stabil. Einige Leute mögen sich fragen, warum die Eingabeaufforderung das Ausgabeformat nicht einschränkt, aber das Ausgabeformat ist immer SVG und stabil.

Der Grund für die Verwendung von LISP ist, dass es eine bessere Beschreibung strukturell komplexer Ursache-Wirkungs-Beziehungen und Stile ermöglicht.

Wir begannen mit Schlagwörter für Kartendiagramme: Generieren Sie Schlagwörter für verschiedene Arten von wissenschaftlichen Präsentationsillustrationen/PPT-Visualisierungskarten Erläutern Sie dies anhand eines Beispiels im Detail:

1. Sprachliche Unterschiede erklärt:

• Die Eingabeaufforderungen sind in LISP geschrieben, einer funktionalen Programmiersprache.
• Die Ausgabe ist SVG (Scalable Vector Graphics), eine XML-basierte Vektorgrafik-Auszeichnungssprache.
• Es handelt sich um zwei völlig unterschiedliche Sprachen, die unterschiedlichen Zwecken dienen.

2. LISP-Code-Rollen:

• Der LISP-Code hier ist eigentlich ein "Generator" oder eine "Template Engine".
• Sie definiert eine Reihe von Funktionen, die die Daten verarbeiten und schließlich den SVG-Code erzeugen.
• Zu den wichtigsten Funktionen gehören:

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

3. Umwandlungsprozess:

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

4. Konkrete Beispiele:

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

5. Erläuterung der Beziehung:

• Der LISP-Code ist das "Kochrezept": Er definiert die Schritte, mit denen die Daten verarbeitet und die Diagramme erstellt werden.
• SVG ist das "letzte Gericht": die endgültige Form der Visualisierung
• Der LISP-Code enthält die gesamte Logik und die Regeln, die für die Erzeugung des SVG erforderlich sind.
• SVG ist das Produkt der Ausführung von LISP-Code

6. Arbeitsablauf:
7. LISP-Code erhält Eingabeparameter (z. B. Themen, Daten usw.)
8. Verarbeitung dieser Parameter (z.B. Berechnung der Position, Auswahl der Farben, etc.)
9. Einfügen von verarbeiteten Daten in SVG-Vorlagen
10. Kompletten SVG-Code ausgeben
11. Vorteil:

• Diese Trennung ermöglicht:
  • LISP beherrscht komplexe Logik und Datenkonvertierung
  • SVG konzentriert sich auf die visuelle Darstellung
  • Leichtere Wartung und Änderung
  • Verschiedene Visualisierungen können auf der Grundlage unterschiedlicher Eingaben erstellt werden

8. Beispiele für Anwendungen aus der Praxis:

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

Umrechnen in:

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

Dies ist wie ein Übersetzungsprozess: Der LISP-Code definiert die "Regeln" und die "Logik", und diese Regeln werden schließlich in eine konkrete grafische Beschreibung in SVG übersetzt. Dieser Ansatz ermöglicht es uns, die Visualisierung in LISP-Pseudocode zu beschreiben und zu steuern, anstatt den SVG-Code manuell zu schreiben.

Find Another Essay On Ist es notwendig, Prompts in Lisp zu schreiben?

Manche Leute spielen mit Schlagwörtern in einem technischen Stil, wie ich. Mir ging es bisher nur darum, die Aufgabe klar und deutlich zu formulieren. Deshalb habe ich mir nicht die Mühe gemacht, irgendwelche Frameworks, Vorlagen oder Techniken zu lernen oder viel Zeit damit zu verbringen, die von mir geschriebenen Stichworte zu verfeinern.

Ich war schon immer der Meinung, dass Sofortengineering kein angemessener Begriff ist und das Wort "Engineering" falsch verwendet wird. Der Gegenstand und das Ergebnis des Engineerings sollte ein System sein, nicht ein Absatz oder viele Absätze von Text.

Wenn Sie einfach nur Prompts schreiben, anstatt Arbeitsabläufe zu entwerfen und sie in eine komplexe Anwendung einzubetten, dann ist das eher ein Handwerk.

Wie beim Schreiben ist auch beim Prompting handwerkliches Geschick gefragt. Wenn Sie sich darauf einlassen und es gut machen, können Sie Prompts sogar in Kunst verwandeln, wie Li Jigang.## Die Lisp-Sprache und ihre Syntax

Die Aufforderungen von Jigang Li haben eine Besonderheit - sie sind in Lisp geschrieben. Hier ist zum Beispiel ein Hinweis:

;;作者:
李继刚
;;版本: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 ist eine "alte" Programmiersprache, und sie hat einen Vorteil - ihre Syntax ist sehr einfach und schön. Das Herzstück der Syntax ist die Listenstruktur oder der "S-Ausdruck", der typischerweise durch ein Klammerpaar gekennzeichnet ist, das die Elemente einschließt; Listen können innerhalb einer Listenstruktur verschachtelt werden, so dass ein Lisp-Programm wie ein Klammerpaar aussieht, das innerhalb eines Klammerpaares verschachtelt ist, das innerhalb eines Klammerpaares verschachtelt ist.

Die Listenstruktur macht die Syntax von Lisp einfach genug, aber gleichzeitig sehr ausdrucksstark. Es sind diese beiden Dinge, die es schön machen.

Man könnte meinen, dass die wichtigste Funktion einer Sprache darin besteht, die Semantik zu vermitteln, und dass die Syntax nicht wirklich so wichtig ist. Wenn Sie ein Programmierer sind, sehen Sie das nicht so. Für Programmiersprachen ist die Syntax wichtig.

Spielt die Syntax bei großen Sprachmodellen eine Rolle?

Wenn man sich die Prompts von Jigang Li ansieht, stellt sich die Frage: Ist es notwendig, Prompts in der Sprache Lisp zu schreiben?

Als nächstes wollen wir das Stichwort "kleines Vermögen" als Beispiel dekonstruieren.

Kann LLM Lisp-Programme verstehen?

Die Eingabeaufforderung "Kleines Glück" hat neben dem Teil der Rolleneinstellung (Funktion) zwei Hauptaufgaben: Erstens verarbeitet sie den vom Benutzer eingegebenen Text und erzeugt einen Ausdruck für kleines Glück (Funktion), und zweitens erzeugt sie eine SVG-Karte (Funktion). Sie beschreibt eigentlich einen einfachen Arbeitsablauf in Lisp.

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

Diese Funktion enthält wiederum eine Reihe von Teilschritten: → → → → → → → . Die Autoren erwarten, dass das große Sprachmodell diesen Teilschritten folgt, um den Prozess zu durchlaufen und eine Zeile auszugeben. Die Funktion definiert auch einige wenige Beispiele, die das große Sprachmodell lernen soll. Schließlich wird die Funktion in dieser Funktion aufgerufen, die als Argument übergeben wird. Die Funktion schließt die Aufgabe der Erzeugung des SVG-Kartenmaterials ab.

Es ist erstaunlich, wie viele Informationen in einen kurzen Absatz gepresst werden! Das liegt zum einen an der Natur der Programmiersprachen selbst, die besonders gut darin sind, Abläufe zu beschreiben. Andererseits ist Lisp eine spezielle Programmiersprache, die den Vorteil hat, sehr prägnant und sehr ausdrucksstark zu sein.

Programme sind schwer zu verstehen, weil man viel dekodieren muss, wenn man ein Stück Code liest. Und man muss der Logik des Programminterpreters folgen, der das Programm ausführt, um den Code zu entschlüsseln.

Kann das große Sprachmodell also das Programm "lesen"?

Man wirft dieses Programm der KI vor und lässt sie es interpretieren, und sie sollte in der Lage sein, es gut zu interpretieren. Es ist jedoch schwierig, dieses Programm als Anhaltspunkt für das große Sprachmodell zu verwenden, um es gemäß der im Programm beschriebenen Logik zu interpretieren und auszuführen. Wenn das Programm komplexere Funktionsaufrufe enthält, wird es für das große Sprachmodell noch schwieriger, damit umzugehen, da das große Sprachmodell dafür nicht ausgelegt ist. Das ist die Aufgabe des Interpreters.

Hier stellt sich die Frage: Wie können wir sicher sein, dass die im Programm definierten Teilschritte in der richtigen Reihenfolge und ohne Auslassungen ausgeführt wurden?

Wenn Sie Claude diesen Hinweis geben und den Text eingeben, wird Claude wahrscheinlich nur den SVG-Code ausgeben. Hier verwende ich Poe Das Claude-Modell auf der Plattform, die offizielle Anthropic-Version ist nicht bekannt, Sie können es selbst testen. Wenn Sie die Claude-API direkt aufrufen, ist es 100% Ausgabe SVG-Code.

Wurden die Teilschritte dieser Funktionsdefinition ausgeführt, und haben die Beispiele mit wenigen Bildern funktioniert? Wurde die Funktion ausgeführt oder nicht? Oder wird nur die Funktion ausgeführt?

Wir haben keine Möglichkeit, das zu wissen. Wenn das große Sprachmodell keine Zwischenprozesse ausgibt, dann dienen die Schlüsselwörter, die die Teilschritte angeben, nur als Anker im Kontext. Es ist schwer zu sagen, ob sie funktionieren oder nicht, und was sie tun.

Andrej Karpathy sagt: "Models brauchen Token zu denken". Wenn ein großes Sprachmodell den "Denk"-Prozess nicht mit Token externalisiert, dann ist es fast dasselbe, als würde es überhaupt nicht "denken". (PS: Die GPT o1-Modellfamilie internalisiert den "Denk"-Prozess auch nicht, sie benötigt immer noch externe Token, um die lange Kette des "Denkens" zu vervollständigen, aber OpenAI verbirgt die Zwischenergebnisse).

Wäre Markdown nicht einfacher zu handhaben?

Normalerweise schreiben wir Prompts in der Markdown-Syntax, die sehr einfach ist, und das Big Language Model "versteht" Überschriften, Listen, fette Hervorhebungen usw. sehr gut.

Wäre es nicht einfacher, die Eingabeaufforderung in Markdown zu schreiben? Übersetzen wir diese Lisp-Eingabeaufforderung in Markdown und probieren sie aus.

## 系统角色设定

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

## 核心功能

###
生成小确幸表达

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

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

Die Markdown- und Lisp-Versionen der Aufforderungen sind semantisch fast identisch. Ich habe nur den Satz "Denken Sie Schritt für Schritt und folgen Sie den großen Schritten und dem Verarbeitungsfluss" hinzugefügt. Denn ohne diesen Satz kann Claude nicht garantieren, dass er Schritt für Schritt vorgehen wird.

Hier ist die Ausgabe der Lisp-Version der Eingabeaufforderung. Wenn ich Claude über die API aufrufe, ist die Ausgabe aus irgendeinem Grund kaum auf dem Niveau des Artikels von Li Jigang, so dass es vielleicht besser ist, die Webversion zu verwenden.

So sieht die Markdown-Version der Prompt-Word-Ausgabe aus:

Der Vergleich der beiden Ergebnisse zeigt einen deutlichen Unterschied: Der Reichtum und die Ausdruckskraft von SVG-Grafiken ist in der Lisp-Version durchgehend besser als in der Markdown-Version. Dies ist eine unerwartete Erkenntnis! Wir werden dies später noch genauer untersuchen.

Ein weiterer wichtiger Unterschied zwischen der Markdown-Version und der Lisp-Version der Eingabeaufforderung liegt im Ausführungsprozess, der den zwischengeschalteten "Denkprozess" ausgibt. Alle Teilschritte der Funktion werden vollständig expandiert und sequentiell ausgeführt. Außerdem wird aufgrund des autoregressiven Mechanismus des Big Language Model die Ausgabe der vorherigen Schritte natürlich als Kontext an die folgenden Schritte weitergegeben.

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

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

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

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

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

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

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

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

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

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

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

接下来生成SVG卡片：

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

Obwohl Sie bei dieser Aufgabe vielleicht keinen großen Unterschied in Bezug auf die textverarbeitete Ausgabe sehen, ist es in den meisten Szenarien von Vorteil, auf diese Weise Schritt für Schritt zu denken.

Einer der großen Vorteile eines großen Sprachmodells, das den "Denk"-Prozess externalisiert, ist außerdem, dass man den Prozess debuggen und optimieren kann. Anhand der Prozessausgabe können Sie sehen, welche Schritte nützliche inkrementelle Informationen erzeugen und welche nicht. Darüber hinaus können Sie während der Fehlersuche in der Ausgabe des großen Sprachmodells neue Anregungen finden.

Bei der Lisp-Version des Stichworts ist es jedoch schwierig, das große Sprachmodell dazu zu bringen, einen Prozess auf so organisierte Weise auszuführen.

Kann die Lisp-Syntax Wunder bewirken?

Wir haben festgestellt, dass in Lisp geschriebene Prompts deutlich bessere SVG-Grafiken erzeugen als die Markdown-Version.

Dies ist ein wenig kontraintuitiv. Denn im Allgemeinen würde man denken, dass das Ziel von Schreibaufforderungen darin besteht, die Aufgabe klar zu beschreiben, d. h. die Semantik zu vermitteln, und dass die Grammatik wenig oder gar keine Auswirkungen haben sollte, und selbst wenn sie es tut, ist es unwahrscheinlich, dass sie so offensichtlich ist.

Hier ist eine meiner intuitiven Erklärungen.

Dies hängt mit der Art der Aufgabe zusammen, und hier wird das große Sprachmodell gebeten, SVG-Code zu erzeugen. Die zugrundeliegende Architektur eines typischen großen Sprachmodells ist ein Transformer, und die Transformator Transformers wurden zuerst für die Übersetzung verwendet, und Transformer ist darin besonders gut. Übersetzung ist die Abbildung von einer Sprache in eine andere, von einer Sequenz in eine andere, und intuitiv sollte Transformer Lisp in SVG-Code besser übersetzen als natürliche Sprache in SVG-Code, denn Lisp und SVG sind beides Code, und sie liegen näher beieinander.

Wir haben über die Ausdruckskraft von Sprache gesprochen, und hier sind wir durch die Ausdruckskraft von Markdown wirklich eingeschränkt. Es ist schwierig, die Design-Spezifikationen, die Elementzusammensetzung und die Konfigurationsparameter einer SVG-Karte in Markdown zu beschreiben, daher benötigen Sie eine strukturiertere Sprache. Die Listenstruktur von Lisp ist dafür mehr als ausreichend.

## 生成 SVG 卡片

### 设计原则

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

### 卡片设置

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

### 卡片元素

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

Es ist auch wichtig zu beachten, dass Lisp in dieser Funktion eher als beschreibende Sprache denn als prozedurale Sprache verwendet wird. Die Funktion beschreibt eine Struktur oder eine Konfiguration, nicht einen komplexen Prozess, und es sind keine verschachtelten Funktionsaufrufe beteiligt. Intuitiv ist das Mapping von einer Struktur auf eine andere relativ einfach.

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

Aus dieser Erfahrung lässt sich eine allgemeinere Intuition ableiten: Bei großen Sprachmodellen ist auch die Syntax von Bedeutung.

In der Praxis würde ich wahrscheinlich die folgende Kombination von Prompt-Wörtern verwenden. Wenn Sie das große Sprachmodell über die Chatbot-Schnittstelle verwenden, kann es nur zu einem Prompt-Wort wie diesem zusammengesetzt werden. Im Allgemeinen würde ich den Prozess jedoch in einen Workflow aufteilen, indem ich das große Sprachmodell mehrmals aufrufe.

## 系统角色设定

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

##
核心功能

###
生成小确幸表达

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

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

So sieht die Ausgabe der Markdown- und Lisp-Hybridversion des Prompt-Worts aus:

Eine weitere Frage......

Wenn unsere bisherigen Annahmen über die Sprachabbildung zutreffen und wenn die Übersetzung der Lisp-Sprache in SVG-Code besser funktioniert, weil Lisp und SVG beides Code sind und näher beieinander liegen, folgt daraus dann nicht, dass die Verwendung einer Sprache, die näher an SVG liegt, besser funktionieren würde?

Welche Sprache kommt SVG am nächsten? Es ist XML, denn SVG ist selbst eine XML-Sprache.

Hier ist die Markdown- und XML-Version des hybriden Stichworts. Diejenigen, die daran interessiert sind, können damit experimentieren und sehen, wie es tatsächlich funktioniert.

## 系统角色设定

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

## 核心功能

###
生成小确幸表达

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

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

Betriebsvorschriften

Nach den Benutzereingaben wird zuerst [Kleine Bürgschaftsausdrücke generieren] und dann [SVG-Karten generieren] aufgerufen.

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

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