世界は再びディープシークにひざまずく

一気に読ませるエッセイ。

世界は再びディープシークにひれ伏した

——残差接続という“常識”が、静かに終わった日。

そのグラフを見た瞬間、
正直、背筋が少し冷えた。

派手な跳ね上がりはない。
革命的な新モデルの名前も出てこない。
あるのは、青とオレンジ、二本の曲線だけだ。

だが、その最後の数エポックで起きていることは、
これまでの深層学習の前提そのものを、
静かに、しかし決定的に否定していた。

残差接続という「成功体験」

深層学習は、長いあいだ「残差接続」に支えられてきた。

層を深くすると学習できなくなる。
その問題を、
「前の情報をそのまま足してしまえばいい」
という、驚くほどシンプルな発想で突破した。

この成功体験があまりに強力だったため、
私たちは無意識のうちに、こう信じてきた。

少なくとも、しばらくのあいだは。

高次元では、何かがおかしかった

しかし、モデルが巨大化し、
表現が高次元の行列になり、
内部状態が「意味の塊」になったとき、
奇妙な現象が頻発し始めた。

・ある深さまでは順調に学習する
・しかし、そこを超えると突然伸びなくなる
・損失は下がらないが、発散もしない
・何かが“濁っている”ような感覚

これはバグではなかった。
学習率の問題でもなかった。

足し算そのものが、限界に来ていた。

直線は、あまりにも素朴だった

今回の数値実験は、
極めてシンプルなニューラルネットワークで行われた。

アテンションもない。
トランスフォーマーですらない。
ただ、残差接続があるかどうか。

そしてもう一方には、
残差に「方向を調整する自由度」を与えたモデルがある。

やっていることは単純だ。

• 情報をそのまま足すのではなく

• その前に「どの向きに進むべきか」を学習させる

それだけで、結果は決定的に変わった。

グラフが語っていること

最初の段階では、確かに両者は似ている。
通常の残差接続も、そこそこうまく進む。

だが、ある時点から違いが現れる。

通常の残差は、
「これ以上、進みようがない場所」に到達する。

一方、曲線的な残差を持つモデルは、
そこで止まらない。

最後の最後で、もう一段、深く潜る。

これは偶然ではない。

それは、
「空間の形を理解しているかどうか」
の違いだ。

情報は、空間の中を流れている

高次元の表現空間では、
情報はもはや点ではない。

方向を持ち、
歪みを持ち、
他の成分と絡み合いながら流れている。

そこを、
「全部まとめて足せばいい」
という扱い方をすれば、どうなるか。

低次元では目立たなかった誤差が、
高次元では致命的になる。

情報は壊れないが、
意味が薄まる。

これが、
深くすると効かなくなる正体だった。

ディープシークが見抜いたもの

ディープシークのチームが到達したのは、
派手な新機構ではない。

彼らが見抜いたのは、
もっと地味で、しかし根本的な事実だ。

つまり、

• 直線で進むか

• 曲がりながら進むか

その違いが、
最終的な到達点を変えてしまう段階に、
我々はすでに入っていた。

なぜ今まで見逃されていたのか

理由は単純だ。

• 小さなモデルでは起きにくい

• 浅い層では顕在化しない

• 計算コストの制約が厳しかった

そして何より、

が、全員の目を曇らせていた。

静かな革命

この実験の恐ろしさは、
その静けさにある。

対数グラフですからね、これはね

構造はほとんど同じ。
パラメータも少ししか増えていない。
計算量も大差ない。

それでも、
到達できる場所が違う。

これは性能改善ではない。
地形の理解が変わったのだ。

世界は、再びひれ伏す

かつて、
「安く、強いモデル」を作って世界を驚かせたディープシークは、
今度はもっと根源的なところに手を入れた。

それはモデルの表面ではない。
学習の流れそのものだ。

残差接続という、
誰も疑わなかった前提に、
静かに、しかし決定的にメスを入れた。

この一枚のグラフは、
こう告げている。

そしてそれを、
最初に形にして見せたのが、
ディープシークだった。

世界が、再びひれ伏す理由は、
十分すぎるほど揃っている。

# =========================================
# Residual vs NHC (Curved Residual) Experiment
# =========================================

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt
torch.manual_seed(42)

device = "cuda" if torch.cuda.is_available() else "cpu"
print("Device:", device)

# -----------------------------------------
# Synthetic task: nonlinear regression
# -----------------------------------------
def make_data(n=2048):
    x = torch.randn(n, 10)
    y = torch.sin(x.sum(dim=1, keepdim=True))  # nonlinear target
    return x.to(device), y.to(device)

x_train, y_train = make_data()

# -----------------------------------------
# Standard Residual Block
# -----------------------------------------
class ResidualBlock(nn.Module):
    def __init__(self, dim):
        super().__init__()
        self.f = nn.Sequential(
            nn.Linear(dim, dim),
            nn.Tanh(),
            nn.Linear(dim, dim)
        )

    def forward(self, x):
        return x + self.f(x)

# -----------------------------------------
# NHC-style Residual Block (Curved)
# -----------------------------------------
class NHCBlock(nn.Module):
    def __init__(self, dim):
        super().__init__()
        self.f = nn.Sequential(
            nn.Linear(dim, dim),
            nn.Tanh(),
            nn.Linear(dim, dim)
        )
        # 学習可能な曲率行列（初期はほぼ恒等）
        self.A = nn.Parameter(torch.eye(dim) + 0.01 * torch.randn(dim, dim))

    def forward(self, x):
        dx = self.f(x)
        dx_curved = dx @ self.A.T
        return x + dx_curved

# -----------------------------------------
# Full Models
# -----------------------------------------
class ResidualNet(nn.Module):
    def __init__(self, dim=10, depth=6):
        super().__init__()
        self.blocks = nn.Sequential(*[ResidualBlock(dim) for _ in range(depth)])
        self.out = nn.Linear(dim, 1)

    def forward(self, x):
        x = self.blocks(x)
        return self.out(x)

class NHCNet(nn.Module):
    def __init__(self, dim=10, depth=6):
        super().__init__()
        self.blocks = nn.Sequential(*[NHCBlock(dim) for _ in range(depth)])
        self.out = nn.Linear(dim, 1)

    def forward(self, x):
        x = self.blocks(x)
        return self.out(x)

# -----------------------------------------
# Training loop
# -----------------------------------------
def train(model, epochs=200):
    optimizer = optim.Adam(model.parameters(), lr=1e-3)
    loss_fn = nn.MSELoss()
    losses = []

    for _ in range(epochs):
        optimizer.zero_grad()
        y_pred = model(x_train)
        loss = loss_fn(y_pred, y_train)
        loss.backward()
        optimizer.step()
        losses.append(loss.item())

    return losses

# -----------------------------------------
# Run experiments
# -----------------------------------------
res_model = ResidualNet().to(device)
nhc_model = NHCNet().to(device)

res_loss = train(res_model)
nhc_loss = train(nhc_model)

# -----------------------------------------
# Visualization
# -----------------------------------------
plt.figure(figsize=(8,5))
plt.plot(res_loss, label="Standard Residual")
plt.plot(nhc_loss, label="NHC (Curved Residual)")
plt.yscale("log")
plt.xlabel("Epoch")
plt.ylabel("MSE Loss (log)")
plt.title("Residual vs NHC Convergence")
plt.legend()
plt.grid(True)
plt.show()

print("Final loss (Residual):", res_loss[-1])
print("Final loss (NHC):", nhc_loss[-1])