return t.to(device, dtype if t.is_floating_point() or t.is_complex() else None, non_blocking) torch.cuda.OutOfMemoryError: CUDA out of memory. Tried to allocate 146.00 MiB (GPU 0; 6.00 GiB total capacity; 8.20 MiB already allocated; 4.18 GiB free; 22.00 MiB reserved in total by PyTorch) If reserved memory is >> allocated memory try setting max_split_size_mb to avoid fragmentation. See documentation for Memory Management and PYTORCH_CUDA_ALLOC_CONF

/home/dss/Code/7_20/Condition_DDPM_7_20.py:14: DeprecationWarning: Please use rotate from the scipy.ndimage namespace, the scipy.ndimage.interpolation namespace is deprecated. from scipy.ndimage.interpolation import rotate Traceback (most recent call last): File "/home/dss/Code/7_20/Condition_DDPM_7_20.py", line 509, in <module> ddpm = DDPM(device, beta_1, beta_T, T, drop_prob=0.1) File "/home/dss/Code/7_20/Condition_DDPM_7_20.py", line 309, in init self.model = UNet(T).to(device) File "/home/dss/.conda/envs/DSS_env/lib/python3.9/site-packages/torch/nn/modules/module.py", line 1145, in to return self._apply(convert) File "/home/dss/.conda/envs/DSS_env/lib/python3.9/site-packages/torch/nn/modules/module.py", line 797, in _apply module._apply(fn) File "/home/dss/.conda/envs/DSS_env/lib/python3.9/site-packages/torch/nn/modules/module.py", line 797, in _apply module._apply(fn) File "/home/dss/.conda/envs/DSS_env/lib/python3.9/site-packages/torch/nn/modules/module.py", line 797, in _apply module._apply(fn) File "/home/dss/.conda/envs/DSS_env/lib/python3.9/site-packages/torch/nn/modules/module.py", line 820, in _apply param_applied = fn(param) File "/home/dss/.conda/envs/DSS_env/lib/python3.9/site-packages/torch/nn/modules/module.py", line 1143, in convert return t.to(device, dtype if t.is_floating_point() or t.is_complex() else None, non_blocking) File "/home/dss/.conda/envs/DSS_env/lib/python3.9/site-packages/torch/cuda/init.py", line 239, in _lazy_init raise AssertionError("Torch not compiled with CUDA enabled") AssertionError: Torch not compiled with CUDA enabled

可以使用 torch.cuda.is_available() 函数来检查是否有可用的 CUDA 设备，并使用 torch.cuda.device() 函数将模型和张量移动到 CUDA 设备上。希望这些步骤能帮助你解决问题！如果还有其他疑问，请随时提问。

def learn(self): if not self.memory.ready(): return states, actions, rewards, next_states, terminals = self.memory.sample_buffer() batch_idx = np.arange(self.batch_size) states_tensor = T.tensor(states, dtype=T.float).to(device) rewards_tensor = T.tensor(rewards, dtype=T.float).to(device) next_states_tensor = T.tensor(next_states, dtype=T.float).to(device) terminals_tensor = T.tensor(terminals).to(device) with T.no_grad(): q_ = self.q_target.forward(next_states_tensor) q_[terminals_tensor] = 0.0 target = rewards_tensor + self.gamma * T.max(q_, dim=-1)[0] q = self.q_eval.forward(states_tensor)[batch_idx, actions] loss = F.mse_loss(q, target.detach()) self.q_eval.optimizer.zero_grad() loss.backward() self.q_eval.optimizer.step() self.update_network_parameters() self.epsilon = self.epsilon - self.eps_dec if self.epsilon > self.eps_min else self.eps_min

这是一段代码，看起来是用于强化学习中的Q-learning算法的训练过程。可以看出，这段代码中包含了经验回放、更新目标网络、计算Q值、计算损失函数、反向传播、更新网络参数等步骤。其中，Q-learning算法是一种基于值...

def gcn_norm(edge_index, edge_weight=None, num_nodes=None, improved=False, add_self_loops=True, flow="source_to_target", dtype=None): fill_value = 2. if improved else 1. if isinstance(edge_index, SparseTensor): assert flow in ["source_to_target"] adj_t = edge_index if not adj_t.has_value(): adj_t = adj_t.fill_value(1., dtype=dtype) if add_self_loops: adj_t = fill_diag(adj_t, fill_value) deg = sparsesum(adj_t, dim=1) deg_inv_sqrt = deg.pow_(-0.5) deg_inv_sqrt.masked_fill_(deg_inv_sqrt == float('inf'), 0.) adj_t = mul(adj_t, deg_inv_sqrt.view(-1, 1)) adj_t = mul(adj_t, deg_inv_sqrt.view(1, -1)) return adj_t else: assert flow in ["source_to_target", "target_to_source"] num_nodes = maybe_num_nodes(edge_index, num_nodes) if edge_weight is None: edge_weight = torch.ones((edge_index.size(1), ), dtype=dtype, device=edge_index.device) if add_self_loops: edge_index, tmp_edge_weight = add_remaining_self_loops( edge_index, edge_weight, fill_value, num_nodes) assert tmp_edge_weight is not None edge_weight = tmp_edge_weight row, col = edge_index[0], edge_index[1] idx = col if flow == "source_to_target" else row deg = scatter_add(edge_weight, idx, dim=0, dim_size=num_nodes) deg_inv_sqrt = deg.pow_(-0.5) deg_inv_sqrt.masked_fill_(deg_inv_sqrt == float('inf'), 0) return edge_index, deg_inv_sqrt[row] * edge_weight * deg_inv_sqrt[col]

- edge_weight：边的权重，可选参数，默认为None。如果不提供权重，则默认为全1. - num_nodes：节点的数量，可选参数，默认为None。如果不提供数量，则通过edge_index推断得到。 - improved：布尔值，表示是否采用...

class SVDRecommender: def init(self, k=50, ncv=None, tol=0, which='LM', v0=None, maxiter=None, return_singular_vectors=True, solver='arpack'): self.k = k self.ncv = ncv self.tol = tol self.which = which self.v0 = v0 self.maxiter = maxiter self.return_singular_vectors = return_singular_vectors self.solver = solver def svds(self, A): if which == 'LM': largest = True elif which == 'SM': largest = False else: raise ValueError("which must be either 'LM' or 'SM'.") if not (isinstance(A, LinearOperator) or isspmatrix(A) or is_pydata_spmatrix(A)): A = np.asarray(A) n, m = A.shape if k <= 0 or k >= min(n, m): raise ValueError("k must be between 1 and min(A.shape), k=%d" % k) if isinstance(A, LinearOperator): if n > m: X_dot = A.matvec X_matmat = A.matmat XH_dot = A.rmatvec XH_mat = A.rmatmat else: X_dot = A.rmatvec X_matmat = A.rmatmat XH_dot = A.matvec XH_mat = A.matmat dtype = getattr(A, 'dtype', None) if dtype is None: dtype = A.dot(np.zeros([m, 1])).dtype else: if n > m: X_dot = X_matmat = A.dot XH_dot = XH_mat = _herm(A).dot else: XH_dot = XH_mat = A.dot X_dot = X_matmat = _herm(A).dot def matvec_XH_X(x): return XH_dot(X_dot(x)) def matmat_XH_X(x): return XH_mat(X_matmat(x)) XH_X = LinearOperator(matvec=matvec_XH_X, dtype=A.dtype, matmat=matmat_XH_X, shape=(min(A.shape), min(A.shape))) # Get a low rank approximation of the implicitly defined gramian matrix. eigvals, eigvec = eigsh(XH_X, k=k, tol=tol ** 2, maxiter=maxiter, ncv=ncv, which=which, v0=v0) # Gramian matrix has real non-negative eigenvalues. eigvals = np.maximum(eigvals.real, 0) # Use complex detection of small eigenvalues from pinvh. t = eigvec.dtype.char.lower() factor = {'f': 1E3, 'd': 1E6} cond = factor[t] * np.finfo(t).eps cutoff = cond * np.max(eigvals) # Get a mask indicating which eigenpairs are not degenerate tiny, # and create a reordering array for thresholded singular values. above_cutoff = (eigvals > cutoff) nlarge = above_cutoff.sum() nsmall = k - nlarge slarge = np.sqrt(eigvals[above_cutoff]) s = np.zeros_like(eigvals) s[:nlarge] = slarge if not return_singular_vectors: return np.sort(s) if n > m: vlarge = eigvec[:, above_cutoff] ularge = X_matmat(vlarge) / slarge if return_singular_vectors != 'vh' else None vhlarge = _herm(vlarge) else: ularge = eigvec[:, above_cutoff] vhlarge = _herm(X_matmat(ularge) / slarge) if return_singular_vectors != 'u' else None u = _augmented_orthonormal_cols(ularge, nsmall) if ularge is not None else None vh = _augmented_orthonormal_rows(vhlarge, nsmall) if vhlarge is not None else None indexes_sorted = np.argsort(s) s = s[indexes_sorted] if u is not None: u = u[:, indexes_sorted] if vh is not None: vh = vh[indexes_sorted] return u, s, vh将这段代码放入一个.py文件中，用Spyder查看，有报错，可能是缩进有问题，无法被调用，根据这个问题，给出解决办法，给出改正后的完整代码

vh = _augmented_orthonormal_rows(vhlarge, nsmall) if vhlarge is not None else None indexes_sorted = np.argsort(s) s = s[indexes_sorted] if u is not None: u = u[:, indexes_sorted] if vh is not...

from scipy.sparse.linalg import eigsh, LinearOperator from scipy.sparse import isspmatrix, is_pydata_spmatrix class SVDRecommender: def init(self, k=50, ncv=None, tol=0, which='LM', v0=None, maxiter=None, return_singular_vectors=True, solver='arpack'): self.k = k self.ncv = ncv self.tol = tol self.which = which self.v0 = v0 self.maxiter = maxiter self.return_singular_vectors = return_singular_vectors self.solver = solver def svds(self, A): largest = self.which == 'LM' if not largest and self.which != 'SM': raise ValueError("which must be either 'LM' or 'SM'.") if not (isinstance(A, LinearOperator) or isspmatrix(A) or is_pydata_spmatrix(A)): A = np.asarray(A) n, m = A.shape if self.k <= 0 or self.k >= min(n, m): raise ValueError("k must be between 1 and min(A.shape), k=%d" % self.k) if isinstance(A, LinearOperator): if n > m: X_dot = A.matvec X_matmat = A.matmat XH_dot = A.rmatvec XH_mat = A.rmatmat else: X_dot = A.rmatvec X_matmat = A.rmatmat XH_dot = A.matvec XH_mat = A.matmat dtype = getattr(A, 'dtype', None) if dtype is None: dtype = A.dot(np.zeros([m, 1])).dtype else: if n > m: X_dot = X_matmat = A.dot XH_dot = XH_mat = _herm(A).dot else: XH_dot = XH_mat = A.dot X_dot = X_matmat = _herm(A).dot def matvec_XH_X(x): return XH_dot(X_dot(x)) def matmat_XH_X(x): return XH_mat(X_matmat(x)) XH_X = LinearOperator(matvec=matvec_XH_X, dtype=A.dtype, matmat=matmat_XH_X, shape=(min(A.shape), min(A.shape))) eigvals, eigvec = eigsh(XH_X, k=self.k, tol=self.tol ** 2, maxiter=self.maxiter, ncv=self.ncv, which=self.which, v0=self.v0) eigvals = np.maximum(eigvals.real, 0) t = eigvec.dtype.char.lower() factor = {'f': 1E3, 'd': 1E6} cond = factor[t] * np.finfo(t).eps cutoff = cond * np.max(eigvals) above_cutoff = (eigvals > cutoff) nlarge = above_cutoff.sum() nsmall = self.k - nlarge slarge = np.sqrt(eigvals[above_cutoff]) s = np.zeros_like(eigvals) s[:nlarge] = slarge if not self.return_singular_vectors: return np.sort(s) if n > m: vlarge = eigvec[:, above_cutoff] ularge = X_matmat(vlarge) / slarge if self.return_singular_vectors != 'vh' else None vhlarge = _herm(vlarge) else: ularge = eigvec[:, above_cutoff] vhlarge = _herm(X_matmat(ularge) / slarge) if self.return_singular_vectors != 'u' else None u = _augmented_orthonormal_cols(ularge, nsmall) if ularge is not None else None vh = _augmented_orthonormal_rows(vhlarge, nsmall) if vhlarge is not None else None indexes_sorted = np.argsort(s) s = s[indexes_sorted] if u is not None: u = u[:, indexes_sorted] if vh is not None: vh = vh[indexes_sorted] return u, s, vh def _augmented_orthonormal_cols(U, n): if U.shape[0] <= n: return U Q, R = np.linalg.qr(U) return Q[:, :n] def _augmented_orthonormal_rows(V, n): if V.shape[1] <= n: return V Q, R = np.linalg.qr(V.T) return Q[:, :n].T def _herm(x): return np.conjugate(x.T)这段代码中使用的scipy包太旧了，导致会出现报错信息为：cannot import name 'is_pydata_spmatrix' from 'scipy.sparse' (D:\Anaconda\lib\site-packages\scipy\sparse_init.py)，将这段代码修改为使用最新版的scipy包

首先需要将代码中的is_pydata_spmatrix替换为isspmatrix_csr。同时需要将代码开头的导入语句修改为from scipy.sparse.linalg import eigsh, LinearOperator from scipy.sparse import isspmatrix_csr。

class TBase: def init(self, id=None): self.id = id self._dtype = {} # 标记字段类型 k:字段名 v:ETimeFormat时间字段类型/枚举类型 def markField(self, **kwargs): self._dtype.update(kwargs) # 获取字段数据 (text, color) def getFieldDatas(self, fieldname): value, color = getattr(self, fieldname), Qt.black dtype = self._dtype.get(fieldname, value) if dtype == ETimeFormat.time: return time.strftime(dtype.desc, time.gmtime(value)), color elif dtype in [ETimeFormat.datetime, ETimeFormat.date]: return value.strftime(dtype.desc) if value else None, color elif isinstance(dtype, EBase) or isinstance(dtype, enum.EnumMeta): return value.desc, value.ext or color else: return f'{value}', color

self._dtype是一个字典，用于标记字段的类型。markField方法用于更新self._dtype字典，接受关键字参数kwargs，其中键是字段名，值是ETimeFormat时间字段类型或枚举类型。getFieldDatas方法用于获取字段数据，接受一...

def synchronize_between_processes(self): """ Warning: does not synchronize the deque! """ if not is_dist_avail_and_initialized(): return t = torch.tensor([self.count, self.total], dtype=torch.float64, device="cuda") dist.barrier() dist.all_reduce(t) t = t.tolist() self.count = int(t[0]) self.total = t[1]

在分布式环境中，方法创建了一个包含self.count和self.total的Tensor对象t，将其数据类型设置为torch.float64，设备设置为"cuda"。然后，通过调用dist.barrier()方法进行进程同步，确保所有进程在继续执行...

pytorch部分代码如下：train_loss, train_acc = train(model_ft, DEVICE, train_loader, optimizer, epoch,model_ema) for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device, non_blocking=True), Variable(target).to(device,non_blocking=True) samples, targets = mixup_fn(data, target) output = model(samples) optimizer.zero_grad() if use_amp: with torch.cuda.amp.autocast(): loss = torch.nan_to_num(criterion_train(output, targets)) scaler.scale(loss).backward() torch.nn.utils.clip_grad_norm_(model.parameters(), CLIP_GRAD) if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks or global_forward_hooks or global_forward_pre_hooks): return forward_call(*input, **kwargs) class LDAMLoss(nn.Module): def init(self, cls_num_list, max_m=0.5, weight=None, s=30): super(LDAMLoss, self).init() m_list = 1.0 / np.sqrt(np.sqrt(cls_num_list)) m_list = m_list * (max_m / np.max(m_list)) m_list = torch.cuda.FloatTensor(m_list) self.m_list = m_list assert s > 0 self.s = s self.weight = weight def forward(self, x, target): index = torch.zeros_like(x, dtype=torch.uint8) target = torch.clamp(target, 0, index.size(1) - 1) index.scatter_(1, target.unsqueeze(1).type(torch.int64), 1) index = index[:, :x.size(1)] index_float = index.type(torch.cuda.FloatTensor) batch_m = torch.matmul(self.m_list[None, :], index_float.transpose(0,1)) batch_m = batch_m.view((-1, 1)) x_m = x - batch_m output = torch.where(index, x_m, x) return F.cross_entropy(self.soutput, target, weight=self.weight) 报错： File "/home/adminis/hpy/ConvNextV2_Demo/train+ca.py", line 46, in train loss = torch.nan_to_num(criterion_train(output, targets)) # 计算loss File "/home/adminis/anaconda3/envs/wln/lib/python3.9/site-packages/torch/nn/modules/module.py", line 1051, in _call_impl return forward_call(input, **kwargs) File "/home/adminis/hpy/ConvNextV2_Demo/models/utils.py", line 622, in forward index.scatter_(1, target.unsqueeze(1).type(torch.int64), 1) # target.data.view(-1, 1). RuntimeError: Index tensor must have the same number of dimensions as self tensor 帮我看看如何修改源代码

从错误信息来看，index张量的维度和target张量不匹配。你可以尝试检查以下target张量的形状，看是否存在问题。同时，你可以在 index.scatter_ 操作之前，将 index 张量的...target = target.to(x.device)

请详细解释以下代码：class BandedFourierLayer(nn.Module): def init(self, in_channels, out_channels, band, num_bands, length=201): super().init() self.length = length self.total_freqs = (self.length // 2) + 1 self.in_channels = in_channels self.out_channels = out_channels self.band = band # zero indexed self.num_bands = num_bands self.num_freqs = self.total_freqs // self.num_bands + (self.total_freqs % self.num_bands if self.band == self.num_bands - 1 else 0) self.start = self.band * (self.total_freqs // self.num_bands) self.end = self.start + self.num_freqs # case: from other frequencies self.weight = nn.Parameter(torch.empty((self.num_freqs, in_channels, out_channels), dtype=torch.cfloat)) self.bias = nn.Parameter(torch.empty((self.num_freqs, out_channels), dtype=torch.cfloat)) self.reset_parameters() def forward(self, input): # input - b t d b, t, _ = input.shape input_fft = fft.rfft(input, dim=1) output_fft = torch.zeros(b, t // 2 + 1, self.out_channels, device=input.device, dtype=torch.cfloat) output_fft[:, self.start:self.end] = self._forward(input_fft) return fft.irfft(output_fft, n=input.size(1), dim=1) def _forward(self, input): output = torch.einsum('bti,tio->bto', input[:, self.start:self.end], self.weight) return output + self.bias def reset_parameters(self) -> None: nn.init.kaiming_uniform_(self.weight, a=math.sqrt(5)) fan_in, _ = nn.init._calculate_fan_in_and_fan_out(self.weight) bound = 1 / math.sqrt(fan_in) if fan_in > 0 else 0 nn.init.uniform_(self.bias, -bound, bound)

这段代码定义了一个名为BandedFourierLayer的类，继承自PyTorch的nn.Module类，用于实现基于傅里叶变换的卷积神经网络层。具体来说： 1. \_\_init\_\_函数中，初始化了该层的一些参数，包括输入输出通道数、带宽、...

pytorch部分代码如下：class LDAMLoss(nn.Module): def init(self, cls_num_list, max_m=0.5, weight=None, s=30): super(LDAMLoss, self).init() m_list = 1.0 / np.sqrt(np.sqrt(cls_num_list)) m_list = m_list * (max_m / np.max(m_list)) m_list = torch.cuda.FloatTensor(m_list) self.m_list = m_list assert s > 0 self.s = s # self.weight = weight if weight is not None: weight = torch.FloatTensor(weight).cuda() self.weight = weight self.cls_num_list = cls_num_list def forward(self, x, target): index = torch.zeros_like(x, dtype=torch.uint8) index_float = index.type(torch.cuda.FloatTensor) batch_m = torch.matmul(self.m_list[None, :], index_float.transpose(0,1)) # 0,1 batch_m = batch_m.view((x.size(0), 1)) # size=(batch_size, 1) (-1,1) x_m = x - batch_m output = torch.where(index, x_m, x) # return F.cross_entropy(self.soutput, target, weight=self.weight) if self.weight is not None: output = output self.weight[None, :] target = torch.flatten(target) # 将 target 转换成 1D Tensor logit = output * self.s return F.cross_entropy(logit, target, weight=self.weight) for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device, non_blocking=True), Variable(target).to(device,non_blocking=True) # 3、将数据输入mixup_fn生成mixup数据 samples, targets = mixup_fn(data, target) # 4、将上一步生成的数据输入model，输出预测结果，再计算loss output = model(samples) # 5、梯度清零（将loss关于weight的导数变成0） optimizer.zero_grad() loss = criterion_train(output, targets) # 6、若使用混合精度 if use_amp: with torch.cuda.amp.autocast(): # 开启混合精度 # loss = torch.nan_to_num(criterion_train(output, target_a, target_b, lam)) # 计算loss # loss = lam * criterion_train(output, target_a) + (1 - lam) * criterion_train(output, target_b) # 计算 mixup 后的损失函数 scaler.scale(loss).backward() # 梯度放大 torch.nn.utils.clip_grad_norm_(model.parameters(), CLIP_GRAD) # 梯度裁剪，防止梯度爆炸 scaler.step(optimizer) # 更新下一次迭代的scaler scaler.update() # 否则，直接反向传播求梯度 else: # loss = criterion_train(output, targets) loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), CLIP_GRAD) optimizer.step() 报错：) File "/home/adminis/hpy/ConvNextV2_Demo/models/losses.py", line 48, in forward output = torch.where(index, x_m, x) RuntimeError: expected scalar type float but found c10::Half

index = torch.zeros_like(x, dtype=torch.uint8).cuda() index_float = index.type(torch.cuda.FloatTensor) 这样就可以保证 index 和 index_float 的数据类型都是 torch.cuda.FloatTensor，与其他计算...

pytorch部分代码如下：train_loss, train_acc = train(model_ft, DEVICE, train_loader, optimizer, epoch,model_ema) for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device, non_blocking=True), Variable(target).to(device,non_blocking=True) # 3、将数据输入mixup_fn生成mixup数据 samples, targets = mixup_fn(data, target) # 4、将上一步生成的数据输入model，输出预测结果，再计算loss output = model(samples) # 5、梯度清零（将loss关于weight的导数变成0） optimizer.zero_grad() # 6、若使用混合精度 if use_amp: with torch.cuda.amp.autocast(): # 开启混合精度 loss = torch.nan_to_num(criterion_train(output, targets)) # 计算loss scaler.scale(loss).backward() # 梯度放大 torch.nn.utils.clip_grad_norm_(model.parameters(), CLIP_GRAD) if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks or global_forward_hooks or global_forward_pre_hooks): return forward_call(input, **kwargs) class LDAMLoss(nn.Module): def init(self, cls_num_list, max_m=0.5, weight=None, s=30): super(LDAMLoss, self).init() m_list = 1.0 / np.sqrt(np.sqrt(cls_num_list)) m_list = m_list * (max_m / np.max(m_list)) m_list = torch.cuda.FloatTensor(m_list) self.m_list = m_list assert s > 0 self.s = s self.weight = weight def forward(self, x, target): index = torch.zeros_like(x, dtype=torch.uint8) index.scatter(1, target.data.view(-1, 1).type(torch.int64), 1) index_float = index.type(torch.cuda.FloatTensor) batch_m = torch.matmul(self.m_list[None, :], index_float.transpose(0,1)) batch_m = batch_m.view((-1, 1)) x_m = x - batch_m output = torch.where(index, x_m, x) return F.cross_entropy(self.soutput, target, weight=self.weight) 报错：RuntimeError: Expected index [112, 1] to be smaller than self [16, 7] apart from dimension 1 帮我看看如何修改源代码

index = torch.zeros_like(x, dtype=torch.uint8) target = torch.clamp(target, 0, index.size(1) - 1) # 将target的值限制在0到index.size(1)-1之间 index.scatter(1, target.data.view(-1, 1).type(torch.int...

pytorch部分代码如下：class LDAMLoss(nn.Module): def init(self, cls_num_list, max_m=0.5, weight=None, s=30): super(LDAMLoss, self).init() m_list = 1.0 / np.sqrt(np.sqrt(cls_num_list)) m_list = m_list * (max_m / np.max(m_list)) m_list = torch.cuda.FloatTensor(m_list) self.m_list = m_list assert s > 0 self.s = s if weight is not None: weight = torch.FloatTensor(weight).cuda() self.weight = weight self.cls_num_list = cls_num_list def forward(self, x, target): index = torch.zeros_like(x, dtype=torch.uint8) index_float = index.type(torch.cuda.FloatTensor) batch_m = torch.matmul(self.m_list[None, :], index_float.transpose(0,1)) batch_m = batch_m.view((-1, 1)) # size=(batch_size, 1) (-1,1) x_m = x - batch_m output = torch.where(index, x_m, x) if self.weight is not None: output = output * self.weight[None, :] logit = output * self.s return F.cross_entropy(logit, target, weight=self.weight) train_loader = torch.utils.data.DataLoader(dataset_train, batch_size=BATCH_SIZE, shuffle=True,drop_last=True) test_loader = torch.utils.data.DataLoader(dataset_test, batch_size=BATCH_SIZE, shuffle=True) cls_num_list = np.zeros(classes) for , label in train_loader.dataset: cls_num_list[label] += 1 criterion_train = LDAMLoss(cls_num_list=cls_num_list, max_m=0.5, s=30) criterion_val = LDAMLoss(cls_num_list=cls_num_list, max_m=0.5, s=30) mixup_fn = Mixup( mixup_alpha=0.8, cutmix_alpha=1.0, cutmix_minmax=None, prob=0.1, switch_prob=0.5, mode='batch', label_smoothing=0.1, num_classes=classes) for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device, non_blocking=True), Variable(target).to(device,non_blocking=True) # 3、将数据输入mixup_fn生成mixup数据 samples, targets = mixup_fn(data, target) targets = torch.tensor(targets).to(torch.long) # 4、将上一步生成的数据输入model，输出预测结果，再计算loss output = model(samples) # 5、梯度清零（将loss关于weight的导数变成0） optimizer.zero_grad() # 6、若使用混合精度 if use_amp: with torch.cuda.amp.autocast(): # 开启混合精度 loss = torch.nan_to_num(criterion_train(output, targets)) # 计算loss scaler.scale(loss).backward() # 梯度放大 torch.nn.utils.clip_grad_norm(model.parameters(), CLIP_GRAD) # 梯度裁剪，防止梯度爆炸 scaler.step(optimizer) # 更新下一次迭代的scaler scaler.update() # 否则，直接反向传播求梯度 else: loss = criterion_train(output, targets) loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), CLIP_GRAD) optimizer.step() 报错：RuntimeError: Expected index [112, 1] to be smaller than self [16, 7] apart from dimension 1

这个报错是因为在计算batch_m时，index_float的维度是反过来的，应该将index_...batch_m = torch.matmul(self.m_list[None, :], index_float.transpose(1,0)) ... 你可以尝试修改后再运行看看是否还会出现报错。

博途1200恒压供水程序，恒压供水，一拖三，PID控制，3台循环泵，软启动工作，带超压，缺水保护，西门子1200+KTP1000触摸屏

基于PLC的立体车库，升降横移立体车库设计，立体车库仿真，三层三列立体车库，基于s7-1200的升降横移式立体停车库的设计，基于西门子博图S7-1200plc与触摸屏HMI的3x3智能立体车库仿真控制

基于PLC的立体车库，升降横移立体车库设计，立体车库仿真，三层三列立体车库，基于s7-1200的升降横移式立体停车库的设计，基于西门子博图S7-1200plc与触摸屏HMI的3x3智能立体车库仿真控制系统设计，此设计为现成设计，模拟PLC与触摸屏HMI联机，博图版本V15或V15V以上此设计包含PLC程序、触摸屏界面、IO表和PLC原理图

锂电池化成机姆龙NJ NX程序，NJ501-1400，威伦通触摸屏，搭载GX-JC60分支器进行分布式总线控制，ID262.OD2663等输入输出IO模块ADA801模拟量模块全自动锂电池化成分容

锂电池化成机姆龙NJ NX程序，NJ501-1400，威伦通触摸屏，搭载GX-JC60分支器进行分布式总线控制，ID262.OD2663等输入输出IO模块ADA801模拟量模块全自动锂电池化成分容机，整机采用EtherCAT总线网络节点控制，埃斯顿总线伺服，埃斯顿机器人动作控制，AD压力模拟量控制伺服电机进行定位运动，雷赛DM3E步进总线控制，触摸屏读写步进电机电流，极性，方向等参数。触摸屏产量统计。涵盖人机配方一键型功能，故障记录功能，st+梯形图编写，注释齐全。

相关推荐

wav.rar_.wav文件读写_python 音频_python 音频_wav音频_音频

浅谈keras中的keras.utils.to_categorical用法

tf.truncated_normal与tf.random_normal的详细用法

博途1200恒压供水程序，恒压供水，一拖三，PID控制，3台循环泵，软启动工作，带超压，缺水保护，西门子1200+KTP1000触摸屏

基于PLC的立体车库，升降横移立体车库设计，立体车库仿真，三层三列立体车库，基于s7-1200的升降横移式立体停车库的设计，基于西门子博图S7-1200plc与触摸屏HMI的3x3智能立体车库仿真控制

锂电池化成机 姆龙NJ NX程序，NJ501-1400，威伦通触摸屏，搭载GX-JC60分支器进行分布式总线控制，ID262.OD2663等输入输出IO模块ADA801模拟量模块 全自动锂电池化成分容

大家在看

HN8145XR-V5R021C00S260

基2，8点DIT-FFT，三级流水线verilog实现

IBM DS4700磁盘阵列安装配置指南

中南大学943数据结构1997-2020真题&解析

DELPHI7+superobject 1.25

最新推荐

浅谈keras中的keras.utils.to_categorical用法

解决python cv2.imread 读取中文路径的图片返回为None的问题

Pandas的read_csv函数参数分析详解

博途1200恒压供水程序，恒压供水，一拖三，PID控制，3台循环泵，软启动工作，带超压，缺水保护，西门子1200+KTP1000触摸屏

基于PLC的立体车库，升降横移立体车库设计，立体车库仿真，三层三列立体车库，基于s7-1200的升降横移式立体停车库的设计，基于西门子博图S7-1200plc与触摸屏HMI的3x3智能立体车库仿真控制

海康无插件摄像头WEB开发包(20200616-20201102163221)

PCNM空间分析新手必读：R语言实现从入门到精通

生成一个自动打怪的脚本

CarMarker-Animation: 地图标记动画及转向库

5G核心网元性能瓶颈揭秘

锂电池化成机姆龙NJ NX程序，NJ501-1400，威伦通触摸屏，搭载GX-JC60分支器进行分布式总线控制，ID262.OD2663等输入输出IO模块ADA801模拟量模块全自动锂电池化成分容