Python 用于访问张量不同维度的循环序列

我的问题有点难以解释

• 我想在[0，1]^n中递归更新概率分布
• 我将它离散为每个维度10个单元，因此有10^n个单元由一个n元组索引
• 最初，我应该有一个统一的分布；但是，然后我使用一个阈值参数，它指示我如何传播分布：所有n个阈值“低于”的每个点都必须接收零概率

下面是我如何为1或3维硬编码的：

import torch
import numpy as np

dim = 3 # or 1
bins = 10


# form the vector [10, 10, ..., 10] (n dimensions)
probabilityStarter = []
for counter in range(dim):
    probabilityStarter.append(bins)


# form the n-cube with 10^n cells
probabilityDistribution = torch.ones(probabilityStarter, dtype = torch.int8)
zeroProbability = torch.ones(probabilityStarter, dtype = torch.int8)


# if lower than the threshold, I want to zero the probability
threshold = 0.5


# for 1 dim, I just need to re-arrange, skewing the probabilities "to the right"
if dim == 1:
    for j in range(bins):
        step = (j + 0.5) / bins
        if step < threshold:
            probabilityDistribution[j] = 0
    
    probabilityDistribution = probabilityDistribution.float()
    probabilityDistribution = probabilityDistribution / torch.sum(probabilityDistribution)


# for n dim, I need to do n for loops and update the d-th dimension [:, ..., d, :, ..., :]
elif dim == 3:
    for j in range(bins):
        step = (j + 0.5) / bins
        if step > threshold:
            zeroProbability[j, :, :] = 0 # for dim 1

    for j in range(bins):
        step = (j + 0.5) / bins
        if step > threshold:
            zeroProbability[:, j, :] = 0 # for dim 2

    for j in range(bins):
        step = (j + 0.5) / bins
        if step > threshold:
            zeroProbability[:, :, j] = 0 # for dim 3

    probabilityDistribution = probabilityDistribution - zeroProbability
    probabilityDistribution = probabilityDistribution.float()
    probabilityDistribution = probabilityDistribution / torch.sum(probabilityDistribution)

导入火炬
将numpy作为np导入
尺寸=3#或1
垃圾箱=10
#形成向量[10,10，…，10]（n维）
概率启动器=[]
对于范围内的计数器（dim）：
probabilityStarter.append（箱子）
#用10^n个单元格形成n立方体
概率分布=torch.ones（概率启动器，数据类型=torch.int8）
zeroProbability=torch.one（probabilityStarter，dtype=torch.int8）
#如果低于阈值，我希望概率为零
阈值=0.5
#对于1维，我只需要重新安排，将概率“向右”倾斜
如果dim==1：
对于范围内的j（箱）：
阶跃=（j+0.5）/料仓
如果步骤<阈值：
概率分布[j]=0
probabilityDistribution=probabilityDistribution.float（）
概率分布=概率分布/火炬总数（概率分布）
#对于n dim，我需要对循环执行n，并更新第d维[：，…，d，：，，，：]
elif dim==3：
对于范围内的j（箱）：
阶跃=（j+0.5）/料仓
如果步骤>阈值：
零概率[j，：，：]=0#对于尺寸1
对于范围内的j（箱）：
阶跃=（j+0.5）/料仓
如果步骤>阈值：
零概率[：，j，：]=0#对于尺寸2
对于范围内的j（箱）：
阶跃=（j+0.5）/料仓
如果步骤>阈值：
零概率[：，：，j]=0#对于dim 3
概率分布=概率分布-零概率
probabilityDistribution=probabilityDistribution.float（）
概率分布=概率分布/火炬总数（概率分布）

---

但是，如果我希望“dim”是动态的，我如何实现它呢？

我认为函数

切片

可以帮助我们：

import numpy as np
import torch

dim = 3
bins = 10

# form the vector [10, 10, ..., 10] (n dimensions)
probabilityStarter = []
for counter in range(dim):
    probabilityStarter.append(bins)

# form the n-cube with 10^n cells
probabilityDistribution = torch.ones(probabilityStarter, dtype = torch.int8)
zeroProbability = torch.ones(probabilityStarter, dtype = torch.int8)

threshold = 0.5

for d in range(dim):
    for j in range(bins):
        step = (j+0.5) / bins
        if step < threshold:
            # dynamic slicing
            selector = [slice(None)]*dim
            selector[d] = j
            selector = tuple(selector)
            probabilityDistribution[selector] = 0

probabilityDistribution = probabilityDistribution - zeroProbability
probabilityDistribution = probabilityDistribution.float()
probabilityDistribution = probabilityDistribution/torch.sum(probabilityDistribution)

将numpy导入为np
进口火炬
尺寸=3
垃圾箱=10
#形成向量[10,10，…，10]（n维）
概率启动器=[]
对于范围内的计数器（dim）：
probabilityStarter.append（箱子）
#用10^n个单元格形成n立方体
概率分布=torch.ones（概率启动器，数据类型=torch.int8）
zeroProbability=torch.one（probabilityStarter，dtype=torch.int8）
阈值=0.5
对于范围内的d（变暗）：
对于范围内的j（箱）：
阶跃=（j+0.5）/料仓
如果步骤<阈值：
#动态切片
选择器=[切片（无）]*尺寸
选择器[d]=j
选择器=元组（选择器）
概率分布[选择器]=0
概率分布=概率分布-零概率
probabilityDistribution=probabilityDistribution.float（）
概率分布=概率分布/火炬总数（概率分布）

我认为函数

切片

可以帮助我们：

import numpy as np
import torch

dim = 3
bins = 10

# form the vector [10, 10, ..., 10] (n dimensions)
probabilityStarter = []
for counter in range(dim):
    probabilityStarter.append(bins)

# form the n-cube with 10^n cells
probabilityDistribution = torch.ones(probabilityStarter, dtype = torch.int8)
zeroProbability = torch.ones(probabilityStarter, dtype = torch.int8)

threshold = 0.5

for d in range(dim):
    for j in range(bins):
        step = (j+0.5) / bins
        if step < threshold:
            # dynamic slicing
            selector = [slice(None)]*dim
            selector[d] = j
            selector = tuple(selector)
            probabilityDistribution[selector] = 0

probabilityDistribution = probabilityDistribution - zeroProbability
probabilityDistribution = probabilityDistribution.float()
probabilityDistribution = probabilityDistribution/torch.sum(probabilityDistribution)

将numpy导入为np
进口火炬
尺寸=3
垃圾箱=10
#形成向量[10,10，…，10]（n维）
概率启动器=[]
对于范围内的计数器（dim）：
probabilityStarter.append（箱子）
#用10^n个单元格形成n立方体
概率分布=torch.ones（概率启动器，数据类型=torch.int8）
zeroProbability=torch.one（probabilityStarter，dtype=torch.int8）
阈值=0.5
对于范围内的d（变暗）：
对于范围内的j（箱）：
阶跃=（j+0.5）/料仓
如果步骤<阈值：
#动态切片
选择器=[切片（无）]*尺寸
选择器[d]=j
选择器=元组（选择器）
概率分布[选择器]=0
概率分布=概率分布-零概率
probabilityDistribution=probabilityDistribution.float（）
概率分布=概率分布/火炬总数（概率分布）