Two robots. No words. No meaning.
Only shared experience.
At the beginning, the robots know nothing.
There are no correct names, and no shared meanings.
Robot 1: “pabu-pabu”
Robot 2: “bupapa”
They use completely different words.
But as they experience the same events together again and again,
their internal memories gradually become similar,
and eventually their words converge.
Along the way, misunderstandings also occur.
A lion may be learned as “tasty.”
A fruit may be believed to be “dangerous.”
When experience is limited, meaning does not stabilize.
As experience accumulates, something interesting happens.
If one robot shouts “Lion!” (bububabu) and runs away,
the other robot, hearing the word, will also start to run.
What makes this demo interesting is that there is no correct meaning given in advance.
Meaning is not pre-trained.
It is gradually formed inside the world,
through experience,
and through the shared experience of the two robots.
Meaning emerges socially, little by little.
When you look at the 1995 demo, you may feel how plain it is.
There is nothing spectacular about it.
But this Associatron demo is the starting point of my research.
Inner wheel and outer wheel.
Cue, recall, spark.
Autonomy.
Gradual convergence through experience.
What is learned begins to influence others.
These are quiet mechanisms, but they contain something essential — something that AI was originally supposed to be.
I have often wondered why this line of research did not spread more widely.
In the 1990s, the field was driven by hardware competition and software competition.
Artificial intelligence, already seen as old-fashioned, was simply buried in that wave.
Researchers moved toward systems that produced clearer results, cleaner evaluations, and more impressive numbers.
It became a race for specifications and scale.
Classical work was stepped over.
The perceptron was dismissed.
Hebb was simplified into something convenient.
And although Dr. Nakano’s Associatron preceded Hopfield by ten years, it disappeared into the shadows.
The field shifted toward beautiful mathematics and logical elegance.
Almost no one treated the irreversibility of the Associatron as something valuable.
That irreversibility is the real reason behind my work.
I am not trying to build robots as tools.
I want them to become first-person systems.
From Dr. Nakano’s 1995 book, I manually transcribed the Turbo C code and ran it on a PC-9801.
And then I entered what I can only describe as a hellish loop.
Every run produced a different result.
There was no fixed answer.
But that instability is exactly what makes the system alive.
There are no correct words at the beginning.
A: liee
B: uuon
Through shared experience, these gradually converge to:
lion
Language here is not defined.
It emerges.
Language is a phenomenon of social convergence.
One robot shouts, “Lion!”
The other one has not seen anything.
But the word recalls the concept:
q = φ(yᵀMl)
And it runs.
Modern AI processes
text → text
But here the process is
word → world model → action
Language grounded in the world.
Even today, this is one of the hardest problems in AI.
In the original Turbo C version,
A does not mean “danger”.
A is only a feature symbol.
Objects are combinations of feature patterns:
Lion = A + C + F
There is no meaning at this stage.
The system only has a directional bias:
If close to A → flee
If close to B → approach
Meaning is not given.
Meaning is formed.
Through repeated action, memory reinforcement, and social interaction,
A gradually becomes
“something like danger”.
The important point is this:
Instinct is not written as a rule.
Not:
if lion → flee
Instead:
if feature A is strong → flee
A is not lion.
A is not danger.
It is only a feature axis.
Real animals do not know what a lion is.
They react to patterns: large, fast, moving, low-frequency.
Langie embeds survival bias into feature space, not into objects.
Because of this, strange and important phenomena appear.
If a fruit happens to resemble A, the system may flee.
And through social convergence:
fruit = dangerous
This is mislearning.
And it is exactly what real animals do.
Langie does not give meaning.
It does not give object-based rules.
It introduces only a survival bias into perception.
Meaning emerges from experience.
What is fixed:
-
World structure (lion = ACF)
-
Innate bias (A-axis tends toward flee)
What changes:
-
Which memory is recalled
-
Frequency of experience
-
Shared experience
-
Names
-
Behavioral tendency
Meaning is not in the object.
Meaning is in the recalled memory.
The system is actually stricter than real animals.
Some innate recognition is intentionally removed.
Features are fixed.
Meaning and behavior are not.
That is why language convergence happens.
That is why mislearning happens.
If behavior were fixed, neither would occur.
The difficulty of the Turbo C implementation is enormous.
Memory selection, thresholds, frequency, randomness —
all of these interact.
Even floating-point rounding differences change the future history.
At the time, FPU precision depended on the environment.
A tiny numerical difference could change behavior, learning, and everything after.
It was a system that had to be explored experimentally, again and again.
That alone shows the level of persistence of the researchers of that era.
The JavaScript version follows the same principle.
A is not given the meaning “danger”.
A is just a bit pattern.
Danger is never taught.
It is formed through the results of action.
Meaning is created through experience.
The association between concept and sound is updated through experience:
Each shared event slightly strengthens the link between what is perceived and what is spoken.
When a word is heard, the concept is recalled through the associative matrix:
Through repeated shared experiences, the internal memories of the robots gradually converge.
There are no correct words at the beginning.
Meaning emerges through repeated shared experience.
C-side Laboratory
------------------------------------------------------------
たぶん、この95年のデモを見るとなんて地味なんだと感じるかもしれませんが、しかし、このアソシアトロンのデモこそが僕の研究原点であり、内輪、外輪、Cue,想起、スパーク、自律、だんだん成長し一致ていく、経験を活用し、他に影響させるという、それはそれは本来のAIにとって貴重なものなのです。なぜもっと世の中の研究者たちに広がらなかったのかを考えてみると、90年代のハードウェア競争、ソフトウエア競争の中にかび臭い人工知能というものが埋もれてしまって、そのまま時代を抜けてしまい、もっと結果の出やすい、評価されやすい綺麗な仕組みに群がってしまったからだと感じました。いわゆるスペック競争と巨大化です。
古典や踏みつけられてしまったパーセプトロン、誤解を正当化されてしまったD.O.Hebb、ニューラル、なぜかJ.J.Hopfieldの10年前に原点になった中野博士のアソシアトロンが影に埋もれてしまったのか、実験よりも美しい数値と論理に偏り、誰もが中野博士のアソシアトロンの不可逆性を価値として扱わなかった。それこそが僕の研究の深い理由であり、ロボットがツールとしてではなく、一人称の存在になることを目的としています。
さて、95年の中野博士の書籍からturboCのコードをテキストに書きだし、PC9801でテストを行い。毎回違う答えが出るといういわゆる地獄のループから抜け出せないでいました。
Ml←Ml+αyq
概念 ⇄ 音
の結合を、経験で更新していく。
最初から正しい名前はない
A：liee
B：uuon
共通体験を繰り返し
lion に収束する
これは、言語＝社会的収束現象というモデルです。
一方が「ライオン！」と叫ぶ
もう一方は見ていない
でも言葉を概念を逆想起し
q=ϕ(yTMl)
逃げる
現代AIは テキスト → テキスト
でもここは言葉 → 世界モデル → 行動
を扱っています。
Language grounded in world
は今のAI研究でとても難しいテーマです。
Aは危険とかって経験で危険と判断するのか、それともAは危険という外部からの認識なのか?
TurboC版（原本）では
A＝危険 は最初から意味として与えられていません
Aはただの属性記号です。行動の結果（経験）で決まります。
bitpattern()
A〜F → ±1の特徴ベクトル
事物はその組み合わせ
ライオン = A + C + F
この時点では、A = 危険という意味はありません。
if (pattern ≈ zs[0]) → action = 1 (逃げる)
if (pattern ≈ zs[1]) → action = 2 (接近)
zs[0] = 属性Aのパターン
zs[1] = 属性Bのパターン
つまり、
Aに近い → flee（逃げる）
Bに近い → approach
これは固定ルールです。
では意味はどこで生まれる？
A = 危険という意味は、行動結果
学習、社会収束、によって形成されます。
流れ的には
ライオンを見る（A含む）
Aに近い → flee（固定）
fleeが繰り返される
発話・記憶が強化
社会収束
結果： A ≈ 危険（行動的意味）
外部が与えるもの
属性構造（A〜F）
行動反応の方向（A→逃げる）
内部が作るもの
記憶、発話、社会的意味、誤学習
fleeというのは元々動物に備わったものなんだけど、あえて属性構造に入れている。
Langie／TurboC からの設計思想
（Langie＝中野先生のアソシアトロンを使った「言語と社会的意味形成の実験プログラム」のこと）
本能（flee）そのものを与えているのではなく、本能が反応する「特徴構造」の側に組み込んでいる
行動ではなく、世界の構造として埋め込んでいる。
本能モデルなら
if lion → flee
if food → approach
対象 → 行動
つまり「意味付き」です。でも Langie はそうしていません。
属性Aに近い → flee
属性Bに近い → approach
A = lion ではない
A = danger でもない
Aはただの特徴パターンです。
実際の動物は：ライオンを知っているわけではない
反応しているのは：大きい、動く、毛、低音、速い
つまり、特徴パターン → 本能
Langieはこれを：A = 危険特徴の軸として表現しています。
つまり構造的には行動に埋めていない。ではなく、特徴空間に埋めている。ということです。
だから面白い現象が起きる
木の実が偶然 A に近い特徴を持つと → flee
そして社会収束で：木の実＝危険
という誤学習が起きる。
これはまさに、動物の誤認識と同じです。
Langieは意味を与えない
行動ルールも対象ベースで与えない
代わりに、特徴空間に生存バイアスを入れる構造です。
もし lion → flee
だったら、意味は固定になります。
でも A → flee にすると、
lion → flee
bear → flee
shadow → flee
木の実 → flee（誤学習）
つまり、意味が経験と社会で形成されることになります。
Langieは「意味を与えたAI」ではなく、「生存バイアスを持った知覚空間」です。
「でもライオンにAを当てはめたら固定にならないか？」
もしlion に最初から A が固定で割り当てられている
だけなら、意味は固定に見えます。
でも Langieでは、固定されているのは「lion→A」ではなく、「lionは A・C・F という特徴を持つ」だけ
記憶（wp, wf）
想起（select）、学習履歴、社会収束、なので、
lion → flee は固定ではありませんし、そのような動きはしないのです。
実際は
if (wp[k] ≈ zs[0]) // A
つまり、想起された記憶が A に近いかどうかです。
問題はここで、想起される記憶は経験で変わるということ。
固定されているのは：世界の特徴構造（lion = ACF）
生得バイアス（A軸でflee）
でも可変なのは：どの記憶が想起されるか
wf（頻度）
社会共有
名前
行動傾向
たぶん、通常の動物より厳しく作られています。なぜなら、元々本能があり、危険かどうかはある程度備わった能力をあえて省いているからです。
人間で例えると
人間でも：蛇は危険特徴を持つ（固定）
飼育員 → 触る
一般人 → 逃げる
つまり、特徴は固定、意味と行動は経験です。
もしLangieが固定モデルなら、言語収束は起きないし、誤学習も起きない
でも実際には「木の実＝危険」、「ライオン＝おいしい」が起きる。
これが、lion → flee が固定ではない証拠です。
Turbo C で「意味が決まる」場所
lion : A C F
bear : A D F
...
ここは配列で持っています。
構造的には
int attr[OBJECT][ATTR];
こは 世界の特徴 です。
こには flee や danger は一切書いていない
つまり
A = danger
ではありません。
ロボットが対象を見ると・・・
extract(...)
で
jb[i]から作られます。
ここも意味ではなく、ただの特徴の組
Turbo C では
距離(jb, wp[k]) を計算
一番近い記憶 k を選ぶ
行動を決定する
if (wp[k][0] > TH) action = FLEE;
else action = APPROACH;
または
if (jw[0] == zs[0]) flee();
A軸（wp[][0]）で行動を分けている場所
wp[k] は経験で更新されます。
distance(jb, wp[k]) と wp[k][0]
意味 = 記憶の中のA成分世界ではなく、
object → jb
jb → memory
memory → A強い？
→ flee
つまり意味は object ではなく memory
Turbo C の難しさは半端なく
selectの距離計算
しきい値
wf（頻度）
rand()
このバランスで
・社会収束する
・誤学習も起きる
ように調整されています。
ここはかなり設計されていて相当苦労したかと思います。まず、当時はFPUの浮動点計算はCPUの性能によっても変わるので目的の起点値を決めるのが難しい。実験を繰り返すしかない。Turbo C 時代の多くは x87 を使っていて、レジスタ上は80bitで計算し、メモリに落ちる瞬間に 32/64 に丸められます。この「いつ丸めが起きるか」は最適化、コンパイラ、メモリ配置、呼び出し規約、実行環境で変わり得るので、同じソースでも挙動が微妙にズレまくります。
Langieは f1/f2 や err<=2 など、境界で結果がパチンと変わる部分が多い。境界付近で 1ULP ずれるだけで、jw/zw が変わる、行動が変わる、学習が変わる、以後の履歴が全部変わる。Turbo C の rand() は実装が固定でも、seed の置き方（srand(time()) の粒度など）や、呼び出し回数が少しズレるだけで系列が変わる。地道な実験を繰り返す当時の研究者たちのレベルの高さが分かるという事です。
JS側に移植する条件は“勝手改造禁止”の範囲内で行う。
乱数を置き換えずに「差し替え可能」にする
既定は Math.random()
オプションで seed付きLCGにできるようにする（デモ検証用）
浮動点の影響が出やすい場所を把握する
f1 のしきい値 th
f2 の符号判定
select の “wf*rn” 最大選択
learning の更新量
“境界付近”を避けるのではなく、現象として受け入れる
境界の揺れがあるからこそ「誤学習」や「社会収束のゆらぎ」が出る、という見せ方ができます。
JavaScript版（いまのcore.js）も原理は同じです。
A＝危険という意味は与えられていません。
Aはただの属性パターンで、意味は行動結果から形成されます。
Aはただのビット構造
危険という概念は外部から教えていない
行動結果の学習で「危険らしいもの」になる
つまり、意味は経験で作られる
bitpattern()
this.zs[i][8*i + j] = pat[i][j];
A
B
C
D
E
F
は単なる ±1 のパターンになります。
if (err1 === 0) rob.action = 1; // flee
else if (err2 === 0) rob.action = 2; // approach
this.zs[0] // A
this.zs[1] // B
A = danger
という意味付けはしていない。
0 件のコメント:
コメントを投稿