Skip to content
The Chat Archive
llama-4-maverick-17b-128e-instruct· Meta LMArena Human Preference 140K

def fixseed(seed=1234): random.seed(seed) np.random.seed(seed) torch.manualseed(seed)…

  1. User

    def fix_seed(seed=1234): random.seed(seed) np.random.seed(seed) torch.manual_seed(seed)

    fix_seed(seed=42)

    class gcn(): def init(self): pass

    def __call__(self, x):
        mean = torch.mean(x)
        std = torch.std(x)
        return (x - mean)/(std + 10**(-6))  # 0除算を防ぐ
    

    class ZCAWhitening(): def init(self, epsilon=1e-4, device="cuda"): # 計算が重いのでGPUを用いる self.epsilon = epsilon self.device = device

    def fit(self, images):  # 変換行列と平均をデータから計算
        x = images[0][0].reshape(1, -1)
        self.mean = torch.zeros([1, x.size()[1]]).to(self.device)
        con_matrix = torch.zeros([x.size()[1], x.size()[1]]).to(self.device)
        for i in range(len(images)):  # 各データについての平均を取る
            x = images[i][0].reshape(1, -1).to(self.device)
            self.mean += x / len(images)
            con_matrix += torch.mm(x.t(), x) / len(images)
            if i % 10000 == 0:
                print("{0}/{1}".format(i, len(images)))
        self.E, self.V = torch.linalg.eigh(con_matrix)  # 固有値分解
        self.E = torch.max(self.E, torch.zeros_like(self.E)) # 誤差の影響で負になるのを防ぐ
        self.ZCA_matrix = torch.mm(torch.mm(self.V, torch.diag((self.E.squeeze()+self.epsilon)**(-0.5))), self.V.t())
        print("completed!")
    
    def __call__(self, x):
        size = x.size()
        x = x.reshape(1, -1).to(self.device)
        x -= self.mean
        x = torch.mm(x, self.ZCA_matrix.t())
        x = x.reshape(tuple(size))
        x = x.to("cpu")
        return x
    

    (datasetのクラスを自作したので,このあたりの処理が少し変わっています)

    zca = ZCAWhitening() zca.fit(trainval_data)

    val_size = 3000 train_data, val_data = torch.utils.data.random_split(trainval_data, [len(trainval_data)-val_size, val_size]) # 訓練データと検証データに分割

    前処理を定義

    transform_train = # WRITE ME

    transform = # WRITE ME

    データセットに前処理を設定

    trainval_data.transform = transform_train test_data.transform = transform

    batch_size = 64

    dataloader_train = torch.utils.data.DataLoader( train_data, batch_size=batch_size, shuffle=True )

    dataloader_valid = torch.utils.data.DataLoader( val_data, batch_size=batch_size, shuffle=True )

    dataloader_test = torch.utils.data.DataLoader( test_data, batch_size=batch_size, shuffle=False )

    前処理の部分の実装をしてください.

  2. Assistant

    前処理の部分を実装します。

    # 前処理を定義
    transform_train = transforms.Compose([
        ZCAWhitening(epsilon=1e-4, device="cuda"),
        gcn(),
        transforms.ToTensor(),  # すでにTensorになっている場合は不要
    ])
    
    transform = transforms.Compose([
        ZCAWhitening(epsilon=1e-4, device="cuda"),
        gcn(),
        transforms.ToTensor(),  # すでにTensorになっている場合は不要
    ])
    

    ただし、データがすでにTensorになっている場合は、transforms.ToTensor()は不要です。また、ZCAWhiteningクラスはすでに学習済みなので、テストデータに対しては学習済みのzcaインスタンスを使用するように変更する必要があります。

    class ZCAWhiteningTransform:
        def __init__(self, zca):
            self.zca = zca
    
        def __call__(self, x):
            return self.zca(x)
    
    # 前処理を定義
    transform_train = transforms.Compose([
        gcn(),
    ])
    
    transform = transforms.Compose([
        ZCAWhiteningTransform(zca),
        gcn(),
    ])
    
    # データセットに前処理を設定
    train_data.dataset.transform = transform_train  # random_split後のdatasetにアクセス
    val_data.dataset.transform = transform  # random_split後のdatasetにアクセス
    test_data.transform = transform
    

    この実装では、ZCAWhiteningクラスのインスタンスzcaをZCAWhiteningTransformクラスでラップして使用しています。trainval_dataをrandom_splitした後のtrain_dataとval_dataは、trainval_dataへの参照を持っているため、trainval_dataのtransformを変更するのではなく、train_data.dataset.transformとval_data.dataset.transformをそれぞれ変更する必要があります。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.