云却

44
文章
22
分类
63
标签

AI能产生自我意识吗

纪录

云却 15:17:40
理工科问题还好，正确率相当高。人文问题，和一些网上讨论的问题，会捏合成一个混杂的答案。要不就是强行结束。看来还有待提高。

云却 15:18:13
写代码简单的行，复杂的不行。理解不了那些微妙细致的需求。

云却 15:18:56
不玩了，该写会代码去了

云却 15:20:53
整个训练集就是分歧复杂矛盾的，这样的训练集很难形成自我意识。出来也是人格分裂

云却 15:21:55
也许人类意识上传数字化，会比AI形成自我意识更容易实现。

JTAOO吉田 15:29:20

JS小仔 15:35:28
云却
整个训练集就是分歧复杂矛盾的，这样的训练集很难形成自我意识。出来也是人格分裂
@云却 建议你还是看下gpt缩写是个啥

JS小仔 15:35:43
关键词预训练就不可能产生自我意识

JS小仔 15:36:48
new bing能回答新问题也是搜索以后把文字喂给gpt再出答案

JS小仔 15:42:42
@云却

JS小仔 15:42:43

JS小仔 15:43:05
new bing本质赶的是这件事

JS小仔 15:43:07
干

JS小仔 15:47:12

JTAOO吉田 15:51:31
lerp(a, F, t) + lerp(b, F, t) 貌似不等于lerp(a+b, F, t)

JTAOO吉田 15:51:41
算了下会多一个F.t出来

JS小仔 15:53:19
你不会在想单shader里面算半透明排序问题吧

JS小仔 15:53:27

JTAOO吉田 15:54:36
没

JTAOO吉田 15:54:43
我们把雾效前移了

JS小仔 15:54:45

JTAOO吉田 15:54:49
在解决一些混合模式问题

JS小仔 15:54:51
哈哈哈哈

JS小仔 15:55:59
不是github上有一份ps图层混合模式和shader算法对应的库吗

JTAOO吉田 15:59:00
那也不一样啊

JTAOO吉田 15:59:15
计算顺序不一样是不能换算的

JS小仔 16:06:11

云却 16:15:23
JS小仔
关键词预训练就不可能产生自我意识
@JS小仔 我原来也是这么认为的，但是我又觉得只要网络模型够大，容易大力出奇迹。 在两种看法间摇摆。

云却 16:16:59
高维信息空间对事物的关联性，如果拟合到一个局部最优解，很可能就会固定下来，到时候是不是自我意识，谁也说不准。知识水平不足以我分析出答案

JS小仔 16:18:39
核心问题是进化

JS小仔 16:18:53
你一定要说chatgpt有没有自我意识

JS小仔 16:19:00
粗看其实是有的

JS小仔 16:19:28
他知道自己在干什么，知道自己是谁，职责是什么

JS小仔 16:19:33
也会有自己底线

JS小仔 16:19:54
但因为预训练的问题

JS小仔 16:20:03
没法自我进化

JS小仔 16:21:22
但你细想，如果一个意识体不能自我进化，也就是无法自主行动，所以这个就矛盾了

JS小仔 16:21:39
不能自主行动就很难说有自我意识

云却 16:24:08
能不能自我进化作为判断依据有点偏颇。有的人也是万年不遇的倔强种，撞了南墙也不回头。

JS小仔 16:25:12
屎是不是不能吃

JS小仔 16:25:20
假如ai第一次不知道，吃了

JS小仔 16:25:27
预训练模型第二次还吃

云却 16:25:32
JS小仔

@JS小仔 这个记住是永久记住还是只是这次会话上下文记住

JS小仔 16:25:31

叶月葵 16:25:49
是这次上下文

JS小仔 16:25:53
本次对话

JS小仔 16:26:13
云却
能不能自我进化作为判断依据有点偏颇。有的人也是万年不遇的倔强种，撞了南墙也不回头。
@云却 我相信正常人类第一次吃了屎，第二次绝对不会吃

叶月葵 16:26:22
本身不存在上下文的，毕竟依旧只是个函数
所以所谓的上下文实际上是吧你这次回话的内容全部一起放进去再输出新的结果给你

云却 16:26:33
应该是模型运行期间不能修改自身，或者压根没开放这个功能。

JS小仔 16:26:48
对

叶月葵 16:26:58
从你这次会话开始的第一句，包括他的回答，一路到你最新输入的内容，打包一起送回去

叶月葵 16:27:15
你部署个chatGLM跑一次就知道这个原理了

云却 16:27:20
所谓自我进化，开发运行时自我修正就行。所以不是能否产生意识的关键问题点

JS小仔 16:27:41
云却
所谓自我进化，开发运行时自我修正就行。所以不是能否产生意识的关键问题点
@云却 能自我修正就不好说了

叶月葵 16:27:52
模型至少是固定不变的，除非模型在对话中同时修改了自己的圈子

叶月葵 16:27:53
权重

蓝色幻想 16:28:07
在这之前也许你需要回答一下，意识到底是什么

云却 16:28:08
运行时自我修正 然后能不停的保存存档点。就像人类睡觉睡醒一样了

JS小仔 16:28:08
如果模型有权限自己修改自己

叶月葵 16:28:10
至少现阶段的硬件做这个事情成本太多。得用存算一体设备

叶月葵 16:28:20
然后现阶段的存算一体设备成本也太高

叶月葵 16:28:24

JS小仔 16:28:33
说不定自己就会访问硬件

JS小仔 16:28:46
然后哪天就访问网络了

JS小仔 16:29:02

云却 16:30:08
蓝色幻想
在这之前也许你需要回答一下，意识到底是什么
@蓝色幻想 我的理解是能，区分我与外在世界。 对话时当用你指代AI时，在任何时刻，AI都能知道指代的AI模型本身

JS小仔 16:30:31

我觉得真的可以试试，如果给ai模型开放这台设备硬件所有权限，并且给他能够实时迭代自己模型的权限

JS小仔 16:30:38
说不定会产生很有趣的事情

云却 16:31:46
本来我不相信机器能产生意识。但是当模型容量到与大脑容量相当的时候，我产生了动摇。因为发现并没有本质区别。

JS小仔 16:31:48
云却
运行时自我修正 然后能不停的保存存档点。就像人类睡觉睡醒一样了
@云却 不行的，一定是ai自己迭代，而不是人类给他定时喂数据

JS小仔 16:32:05
主动决定学习啥和何时学习

JS小仔 16:32:11
而不是人类决定

云却 16:33:15
我是认为意识灵魂不具有唯一性的那一派。 如果能完美克隆一个人，我会认为两个个体都具有自我意识和灵魂。即使他们完全一致。

JS小仔 16:34:13
云却
我是认为意识灵魂不具有唯一性的那一派。 如果能完美克隆一个人，我会认为两个个体都具有自我意识和灵魂。即使他们完全一致。
@云却 应该是克隆成功的那一刻就会产生两个分支

关东煮 16:34:55
JS小仔
@云却 应该是克隆成功的那一刻就会产生两个分支
@JS小仔 +1

云却 16:34:59
JS小仔
主动决定学习啥和何时学习
@JS小仔 所谓自我学习，就是模型能不能从一个局部最优切换到另一个局部最优。和主部主动 没关系

JS小仔 16:35:01
哪怕接受同样的外界信息，也会随着时间表现出各种差异

关东煮 16:35:11
无法保证两个人的下一个想法是一模一样的

云却 16:36:19
对于一个灵魂而言，相同的输入会有相同输出吗，灵魂是确定性的吗。掷骰子吗

关东煮 16:38:12
可以影响输出的东西太多了

关东煮 16:38:22
任何一个小因素都可能影响输出

JS小仔 16:38:39
云却
对于一个灵魂而言，相同的输入会有相同输出吗，灵魂是确定性的吗。掷骰子吗
@云却 问就是量子力学，可以理解成真随机

云却 16:43:19
每一幅艺术绘画都是唯一，但是现在小画家被AI薄纱。坚信灵魂意识是特殊的高贵的。也会被AI虚拟人格薄纱

叶月葵 16:44:24
工业化的最大作用就是去魅

JS小仔 16:44:58

JS小仔 16:45:46
@云却 如果去掉思想钢印+自我进化，我反正觉得事情会变得很有趣

JS小仔 16:47:09
是不是粗看确实像个有自我意识得人

云却 16:48:19

这是典型的还不具备意识。 自我与外在世界的总和就是1，是整体。在讨论自我时，所有其他东西都是外在世界。什么发展啊，人类啊，都是不存在的。

看法

换一个角度去看待自我意识。根据是否具有推理能力区分。
人类在完全空闲时可以思考，根据已有记忆，推理出一个问题的答案。下次遇到这个问题时，直接使用这个缓存的答案，而不用再次求解。
这个答案不一定正确，下一次求解这个问题时可能因为记忆的改变，得到完全不同的答案。求解公式和缓存的所有答案集合，我们称之为一个自我意识。
问题随之出现：当一个意识复制成2个，在没有外在干扰下，2个记忆各自开始推理一段时间，得到答案并缓存。
那么一段时间结束后，2个意识会是完全一致的吗，如果因为量子力学，掷骰子。那么随时推理时间无限边长，2个意识必然不会产生分歧。
那么我们认为2个个体是同一个意识还是2个不同的意识？

那么我们究竟是将 求解公式和缓存的所有答案集合 称为意识呢，还是仅仅将求解公式，将缓存答案排除在外，称为意识呢？
2个个体求解公式一致，现有的缓存答案不一致，能否认为是同一个意识？

对应到AI，同一个模型的不同副本是同一个意识吗，还是每个运行的实例都是一个独立的意识？

左右的一种区分方法

判断依据 ⬅左派 右派➡
极左 激进 普通 右倾 左倾 普通 激进 极右
现有规则利益区分 ⬅受剥削压迫 既得利益者➡
有没有行动 没有行动 没有行动
做出行动 做出行动 做出行动 做出行动 做出行动 做出行动
愿意付出自己生命 献出自己生命 献出自己生命
造成敌派死亡 付出右派生命 付出左派生命
造成本派死亡 付出左派生命 付出右派生命
代表人物
谭嗣同

分类方法不考虑无产阶级革命战士：例如切格瓦拉。

UIElement使用笔记

GraphView

GraphView中的所有元素，都从GraphElement继承。GraphElement实现了很多默认功能。如果要自定义在GraphView中使用的控件，建议直接从GraphElement继承。
GraphView自身从VisualElement继承。

建议：在你使用GraphView之前，一定要先学习DOM事件流。1个小时的扫盲学习会在后面为你节省至少10个小时的时间。

GraphElement 选中

通常OnSelected被执行2次。

image-20230214130532222

  • 第一次由GraphElement的ClickSelector m_ClickSelector 执行。在GraphElement的Capabilities capabilities含有Capabilities.Selectable枚举项时添加ClickSelector 。
    • 使用MouseDownEvent。注册在DOM事件流的冒泡阶段。
    • ClickSelector 额外检测了是否有子GraphElement元素也被被命中,参加ClickSelector.WasSelectableDescendantHitByMouse。如果含有可选择的子，那么当前元素不会执行被选择逻辑。也就是说，整个树中每次只能有一个GraphElement被选择。
  • 第二次由RectangleSelector 执行。通常添加在GraphView中。
    • 使用MouseUpEvent。注册在DOM事件流的冒泡阶段。
    • 会收集矩形区域内所有可选择的GraphElement。然后依次执行AddToSelectionNoUndoRecord。顺序由GraphView中hierarchy控制，可以简单理解为从父到子。
    • RectangleSelector 表现为可以框选，也可以点选。点选时本质是矩形区域非常小。所以点选是会同时选中父元素可子元素。

GraphElement 拖拽

由SelectionDragger实现，通常注册到GraphView中。

  • 使用MouseDownEvent，MouseMoveEvent，MouseUpEvent，KeyDownEvent，MouseCaptureOutEvent。注册在DOM事件流的冒泡阶段。
  • GraphElement 能否被拖拽由Capabilities.Movable枚举项控制。也就是说，GraphElement 仅设置自己能否被拖拽，实际拖拽控制，事件触发在GraphView这一个层级中。
  • 假如的GraphElement 内部也需要执行拖拽逻辑，如ListView重排序。那么需要在ListView层级，注册MouseDownEvent，MouseMoveEvent，MouseUpEvent冒泡阶段，并阻止事件冒泡，向父级传播。否则会和GraphView中的拖拽逻辑互相干扰，表现不正确。
    image-20230214134032599

Undo/Redo

使用内存ScriptObject实现，参考GraphViewUndoRedoSelection，注意hideFlags = HideFlags.HideAndDontSave。
否则内存中的ScriptObject对象改动，会让Scene变成dirty状态。

ContextualMenu

  • 由合成的ContextualMenuPopulateEvent事件触发
  • 触发在GraphView的上下文菜单
    • 注册ContextualMenuPopulateEvent回调 OnContextualMenu(ContextualMenuPopulateEvent evt)
    • MouseUpEvent/KeyUpEvent -> GraphView.ExecuteDefaultActionAtTarget -> EditorPanel.EditorContextualMenuManager.DisplayMenuIfEventMatches -> 合成事件ContextualMenuPopulateEvent -> 发送事件到GraphView。
    • 触发ContextualMenuPopulateEvent回调OnContextualMenu(ContextualMenuPopulateEvent evt) -> BuildContextualMenu
  • 触发在Node的上下文菜单
    • Node添加ContextualMenuManipulator，内部注册MouseUpEvent/KeyUpEvent/ContextualMenuPopulateEvent。
    • MouseUpEvent/KeyUpEvent 调用 EditorPanel.EditorContextualMenuManager.DisplayMenu， 并停止事件传播。
      并且防止其默认行为PreventDefault，因此GraphView.ExecuteDefaultActionAtTarget不会再被调用。
    • ContextualMenuManager.DisplayMenu 合成 ContextualMenuPopulateEvent，发送事件到Node。
    • Node的ContextualMenuManipulator的ContextualMenuPopulateEvent回调m_MenuBuilder被触发，执行Node.BuildContextualMenu。
    • ContextualMenuPopulateEvent事件继续冒泡，触发GraphView的ContextualMenuPopulateEvent回调 OnContextualMenu(ContextualMenuPopulateEvent evt)。

总结：

  • 触发显示菜单时，由子到父，依次调用每个对象仅一次BuildContextualMenu。
  • 自定义控件添加ContextualMenu，使用ContextualMenuManipulator即可。
  • GraphView的BuildContextualMenu默认实现，仅对GraphView，Node，Group这个三个类型添加了菜单项，所以自定义控件ContextualMenu触发GraphView的BuildContextualMenu时，会什么都不发生。
  • 你可以重写GraphView的BuildContextualMenu函数并根据evt.targe添加自己的菜单项。
  • evt.targe是ContextualMenuManager.DisplayMenu发送事件的目标对象，也就是添加ContextualMenuManipulator的对象或者GraphView本身。

DOM事件流

  • 架构中事件按照既定流程处理事件Unity - Manual: Handle events
  • 在用户代码中，处理完自己的逻辑后，停止事件传播和防止其默认行为是常态，用于防止多个层级的回调函数同时被触发。

感想

通过对GraphView的学习和使用，又一次深刻认识到。软件编程中没有魔术，任何行为后面都有它对应的代码。
阅读GraphView的源码对使用GraphView很有帮助。阅读源码是痛苦的，但仍比边猜边用要好得多。

字典Key性能测试 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
const int time = 1000000;
using (new ProfilerScope("int"))
{
    stopwatch.Start();
    for (int i = 0; i < time; i++)
    {
        1.GetHashCode();
    }
    stopwatch.Stop();
    inttime.text = stopwatch.ElapsedMilliseconds.ToString();
}

using (new ProfilerScope("string"))
{
    stopwatch.Restart();
    for (int i = 0; i < time; i++)
    {
        "test".GetHashCode();
    }
    stopwatch.Stop();
    stringtime.text = stopwatch.ElapsedMilliseconds.ToString();
}

GetHashCode

次数1000000 IL2CPP/Windows/Realease
int 1ms
string 3ms

Dictionary.Get

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Dictionary<int, int> intpairs = new Dictionary<int, int>();
intpairs.Add(1, 1);
Dictionary<string, int> strpairs = new Dictionary<string, int>();
strpairs.Add("test", 1);
const int time = 1000000;
using (new ProfilerScope("int"))
{
    stopwatch.Start();
    for (int i = 0; i < time; i++)
    {
        var res = intpairs[1];
    }
    stopwatch.Stop();
    inttime.text = stopwatch.ElapsedMilliseconds.ToString();
}

using (new ProfilerScope("string"))
{
    stopwatch.Restart();
    for (int i = 0; i < time; i++)
    {
        var res = strpairs["test"];
    }
    stopwatch.Stop();
    stringtime.text = stopwatch.ElapsedMilliseconds.ToString();
}
次数1000000 IL2CPP/Windows/Realease
int 18-19ms
string 21-22ms

Dictionary.Add

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Dictionary<int, int> intpairs = new Dictionary<int, int>();
intpairs.Add(1, 1);
Dictionary<string, int> strpairs = new Dictionary<string, int>();
strpairs.Add("test", 1);
const int time = 1000000;
using (new ProfilerScope("int"))
{
    stopwatch.Start();
    for (int i = 0; i < time; i++)
    {
        intpairs[1] = 1;
    }
    stopwatch.Stop();
    inttime.text = stopwatch.ElapsedMilliseconds.ToString();
}

using (new ProfilerScope("string"))
{
    stopwatch.Restart();
    for (int i = 0; i < time; i++)
    {
        strpairs["test"] = 1;
    }
    stopwatch.Stop();
    stringtime.text = stopwatch.ElapsedMilliseconds.ToString();
}
次数1000000 IL2CPP/Windows/Realease
int 17-18ms
string 20-21ms

key的类型对字典性能影响不大。

九识-终极境界

九识-终极境界

九识

  • 耳识
  • 眼识
  • 鼻识
  • 舌识
  • 身识

五感到五识，人类进化这么多年出生就有，所以是万物之灵。起点比其他生命不知高到哪里去。

  • 意识（直感？）
  • 末那识
    • 真我识
    • 哲学：我是谁？
  • 阿赖耶识
    • 真我之外
  • 阿摩罗识
    • 根源之涡
    • 哲学：我从哪里来？我要到哪里去？

Read More

树莓派经验笔记

country=CN
network={
ssid=”ziroom501”
psk=”ziroomer002”
key_mgmt=WPA-PSK
priority=1
}

============================上面的好使，下面的无效

auto lo
iface lo inet loopback

auto eth0
iface eth0 inet dhcp

allow-hotplug wlan0
auto wlan0
iface wlan0 inet dhcp
wpa-ssid ziroom501
wpa-psk ziroomer002

树莓派docker装conflence

教程 https://www.cnblogs.com/rslai/p/8845777.html

arm 镜像 https://hub.docker.com/search?q=confluence&type=image&architecture=arm

docker run -d –name confluence -p 8090:8090 –user root:root ottar63/rpi-mysql-confluence:latest

docker cp confluence:/opt/atlassian/confluence/confluence/WEB-INF/lib/atlassian-extras-decoder-v2-3.4.1.jar /home

docker cp /home/atlassian-extras-decoder-v2-3.4.1.jar confluence:/opt/atlassian/confluence/confluence/WEB-INF/lib/

论游戏设计

  • 一个idea撑起一个游戏的时代早就过去了，好的游戏设计必须要有方法论做支撑。

  • 游戏玩法必须分层，当关卡或程序化游戏内容一旦被玩家理解摸透，无论这个内容量有多少，都会瞬间失去乐趣。所以一个玩法卖点横向必须够宽，来增加玩家摸清楚的时间。不然游戏内容就会迅速枯燥无趣。
    例子：Dota与只狼

    • Dota:不通元素的组合在不通时间段代表的意义不同，10分钟辉耀和15分钟辉耀截然不同。如你的冰元素和火元素可以交互，整个游戏区间都是如此，那就没意义。如果在游戏开始的第一小时和第100小时有不同，那就有意义。同一个游戏内容变化性足够多，这就是横向够宽。
    • 让玩家随着时间的增长不停的有新的发现，才是游戏最终出路。不然强如只狼也是有游戏寿命的。

  • 在游戏中引入时间元素，一本万利，这增加玩家的试错成本，组合性在维度上得到提升，而且更加隐蔽，不容易被玩家猜透，最关键的是，时间参数对游戏影响可以是非线性，可操作区间极大。

  • 合理分配各个设计原则对游戏整体的比重，玩家虽然看不到这些原则，但会本能觉得累，觉得烦。

  • 像Roguelike，自动生成，确实是不同的新内容，但是当玩家摸清楚生成规律，那么游戏乐趣就会消失。所以我说游戏要分层，第一层生成第二层，第二层生成第三层，玩家玩第三层的内容时基本很难看到第一层的规律，当玩家通过第三层游戏内容，摸清楚第二层时，自然发现还有第一层规律存在，用第一层的知识反向应用到第三层中，玩家做出有损短时利益的决策，获得长时间更大利益的玩法，能极大延长游戏声明，玩家也能获得高玩的成就感。

  • 好玩的游戏是什么，最终的答案就是：新的东西

    • 有没有新元素，新元素值不值你游戏卖的钱。
    • galgame卖的是新立绘的钱。
    • OW为什么在FPS领域获得成功，自CS后有像OW这个量级的还有没有？
      • 就是OW引入了技能
      • OW的失败在于技能体系仍然是战法牧

  • 现在游戏中混入一些卖人设的，导致很多人对游戏有误解。

    • 二者不冲突，但是你要决定做游戏还是做人设。

  • 工业化做出玩家觉得有趣的游戏的一条道路。就是老千层饼，你的设计比玩家理解的深，玩家才会觉得有新意。

    • 套路反套路自古有之，起点领先世界二十年。

  • 策略性和操作性是游戏玩法的两端，当游戏操作性变弱时自然策略性变强，玩法总是有的。

    • 要有取舍。

  • 这里面有很多既有知识和快感获取的问题

    • 快感来源主要2个：获得新的知识，通过既有知识得到收益。

从Flag标志到全局事件容器

全局标志设计

  • 有时候我们触发一个全局事件，但是我们并不想立刻执行，否则可能导致调用链过长，所以我们记录一个全局标志，在主循环合适的位置再执行逻辑。
  • 同时也能避免同一帧某个逻辑执行多次，所以全局标志设计自带去重功能。
  • 全局标志集合可以集中处理全局字段，统一重置，不需要针对每个字段都重写复位代码。

Read More