Skip to main content

· One min read

linux分卷解压命令，亲测有效

!cat model.z* > uns.zip 
!unzip uns.zip

当然得保证所有的分卷都在当前文件夹并且目前位置在当前文件夹，至于为什么要分卷呢，等你遇见限制上传文件大小的玩意就明白了

· 9 min read

pytorch转paddle

  • Pytorch的API名称 Paddle的API名称

  • torch.abs fluid.layers.abs(x, name=None)

  • torch.acos fluid.layers.acos(x, name=None)

  • torch.add fluid.layers.elementwise_add(x, y, axis=-1, act=None, name=None)

  • torch.allclose fluid.layers.allclose

  • torch.arange fluid.layers.range(start, end, step, dtype)

  • torch.argmax fluid.layers.argmax

  • torch.argmin fluid.layers.argmin

  • torch.argsort fluid.layers.argsort(input, axis=-1, descending=False, name=None)

  • torch.as_strided fluid.layers.strided_slice(input, axes, starts, ends, strides):

  • torch.asin fluid.layers.asin(x, name=None)

  • torch.atan fluid.layers.atan(x, name=None)

  • torch.cat fluid.layers.concat(input, axis=0, name=None)

  • torch.ceil fluid.layers.ceil

  • torch.chunk fluid.layers.unstack(x, axis=0, num=None)

  • torch.cos fluid.layers.cos

  • torch.cumsum fluid.layers.cumsum(x, axis=None, exclusive=None, reverse=None)

  • torch.diag fluid.layer.diag(diagonal)

  • torch.diag_embed fluid.layer.diag_embed

  • torch.div fluid.layers.elementwise_div(x, y, axis=-1, act=None, name=None)

  • torch.eq fluid.layers.equal(x, y, cond=None)

  • torch.equal fluid.layers.elementwise_equal(x, y, name=None)

  • torch.equal fluid.layers.equal(x, y, cond=None)

  • torch.erf fluid.layers.erf(x)

  • torch.exp fluid.layers.exp(x, name=None)

  • torch.eye fluid.layers.eye(num_rows, num_columns=None, batch_shape=None, dtype=‘float32’)

  • torch.flatten fluid.layers.flatten

  • torch.flip fluid.layers.flip

  • torch.floor fluid.layers.floor(x, name=None)

  • torch.fmod fluid.layers.elementwise_mod(x, y, axis=-1, act=None, name=None)

  • torch.from_numpy fluid.dygraph.to_variable(value, block=None, name=None)

  • torch.full fluid.layers.full(shape, fill_value, out=None, dtype=None, device=None, stop_gradient=True, name=None)

  • torch.full_like fluid.layers.full_like

  • torch.gather fluid.layers.gather(input, axis, index, out=None, sparse_grad=False, name=None)

  • torch.ge fluid.layers.greater_equal

  • torch.gt fluid.layers.greater_than

  • torch.le fluid.layers.less_equal

  • torch.linspace fluid.layers.linspace(start, stop, num, dtype)

  • torch.log fluid.layers.log(x, name=None)

  • torch.logical_not fluid.layers.logical_not(x, out=None, name=None)

  • torch.logical_xor fluid.layers.logical_xor(x, y, out=None, name=None)

  • torch.lt fluid.layers.less_than

  • torch.masked_select fluid.layers.masked_select

  • torch.matmul fluid.layers.matmul(x, y, transpose_x=False, transpose_y=False, alpha=1.0, name=None)

  • torch.max fluid.layers.max(input, axis=None, keepdim=False, out=None, name=None) -> (Tensor, LongTensor)

  • torch.mean fluid.layers.reduce_mean(input, dim=None, keep_dim=False, name=None)

  • torch.min fluid.layers.min

  • torch.mm fluid.layers.mm

  • torch.mul fluid.layers.mul

  • torch.mv fluid.layers.matmul(x, y, transpose_x=False, transpose_y=False, alpha=1.0, name=None)

  • torch.ne fluid.layers.not_equal

  • torch.nn.AdaptiveAvgPool2d fluid.layers.adaptive_pool2d

  • torch.nn.AdaptiveAvgPool3d fluid.layers.adaptive_pool3d

  • torch.nn.AdaptiveMaxPool2d fluid.layers.adaptive_pool2d

  • torch.nn.AdaptiveMaxPool3d fluid.layers.adaptive_pool3d

  • torch.nn.add_module fluid.dygraph.Layer.add_sublayer(name, sublayer)

  • torch.nn.append fluid.dygraph.LayerList.append(sublayer)

  • torch.nn.append fluid.dygraph.ParameterList.append(parameter)

  • torch.nn.AvgPool2d fluid.layers.pool2d(pool_type为’avg’)

  • torch.nn.AvgPool3d fluid.layers.pool3d(pool_type为’avg’)

  • torch.nn.BatchNorm1d fluid.layers.batch_norm(input, act=None, is_test=False, momentum=0.9, epsilon=1e-05, param_attr=None, bias_attr=None, data_layout=‘NCHW’, in_place=False, name=None, moving_mean_name=None, moving_variance_name=None, do_model_average_for_mean_and_var=False, use_global_stats=False)

  • torch.nn.BatchNorm2d fluid.layers.batch_norm(input, act=None, is_test=False, momentum=0.9, epsilon=1e-05, param_attr=None, bias_attr=None, data_layout=‘NCHW’, in_place=False, name=None, moving_mean_name=None, moving_variance_name=None, do_model_average_for_mean_and_var=False, use_global_stats=False)

  • torch.nn.BatchNorm3d fluid.layers.batch_norm(input, act=None, is_test=False, momentum=0.9, epsilon=1e-05, param_attr=None, bias_attr=None, data_layout=‘NCHW’, in_place=False, name=None, moving_mean_name=None, moving_variance_name=None, do_model_average_for_mean_and_var=False, use_global_stats=False)

  • torch.nn.Bilinear fluid.layers.bilinear_tensor_product(x, y, size, act=None, name=None, param_attr=None, bias_attr=None)

  • torch.nn.ConstantPad1d fluid.layers.pad

  • torch.nn.ConstantPad2d fluid.layers.pad / fluid.layers.pad2d

  • torch.nn.ConstantPad3d fluid.layers.pad

  • torch.nn.Conv2d fluid.dygraph.Conv2D

  • torch.nn.Conv3d fluid.dygraph.Conv3D

  • torch.nn.ConvTranspose2d fluid.layers.conv2d_transpose

  • torch.nn.ConvTranspose3d fluid.layers.conv3d_transpose

  • torch.nn.double fluid.layers.cast(x, dtype)

  • torch.nn.Dropout fluid.layers.dropout(x, dropout_prob, is_test=False, seed=None, name=None, dropout_implementation=‘downgrade_in_infer’)

  • torch.nn.ELU fluid.layers.elu(x, alpha=1.0, name=None)

  • torch.nn.Embedding fluid.dygraph.Embedding

  • torch.nn.eval fluid.dygraph.Layer.eval()

  • torch.nn.float fluid.layers.cast(x, dtype)

  • torch.nn.Fold fluid.layers.unfold

  • torch.nn.functional.adaptive_avg_pool2d fluid.layers.adaptive_pool2d

  • torch.nn.functional.adaptive_avg_pool3d fluid.layers.adaptive_pool3d

  • torch.nn.functional.adaptive_max_pool2d fluid.layers.adaptive_pool2d

  • torch.nn.functional.adaptive_max_pool3d fluid.layers.adaptive_pool3d

  • torch.nn.functional.affine_grid fluid.layers.affine_grid

  • torch.nn.functional.avg_pool2d fluid.layers.pool2d(input, pool_size=-1, pool_type=“max”, pool_stride=1, pool_padding=0, global_pooling=False, use_cudnn=True, ceil_mode=False, name=None, exclusive=True, data_format=“NCHW”)设置pool_type=“avg”

  • torch.nn.functional.avg_pool3d fluid.layers.pool3d(input, pool_size=-1, pool_type=“max”, pool_stride=1, pool_padding=0, global_pooling=False, use_cudnn=True, ceil_mode=False, name=None, exclusive=True, data_format=“NCDHW”)设置pool_type=“avg”

  • torch.nn.functional.cross_entropy fluid.layers.softmax_with_cross_entropy

  • torch.nn.functional.ctc_loss fluid.layers.warpctc

  • torch.nn.functional.elu fluid.layers.elu

  • torch.nn.functional.embedding fluid.embedding

  • torch.nn.functional.embedding_bag fluid.contrib.fused_embedding_seq_pool

  • torch.nn.functional.glu fluid.nets.glu(input, dim=-1)

  • torch.nn.functional.grid_sample fluid.layers.grid_sampler

  • torch.nn.functional.hardshrink fluid.layers.hard_shrink

  • torch.nn.functional.interpolate fluid.layers.interpolate

  • torch.nn.functional.kl_div fluid.layers.kldiv_loss

  • torch.nn.functional.leaky_relu fluid.layers.leaky_relu

  • torch.nn.functional.logsigmoid fluid.layers.logsigmoid

  • torch.nn.functional.margin_ranking_loss fluid.layers.margin_rank_loss(label, left, right, margin=0.1, name=None)

  • torch.nn.functional.max_pool2d fluid.layers.pool2d(input, pool_size=-1, pool_type=“max”, pool_stride=1, pool_padding=0, global_pooling=False, use_cudnn=True, ceil_mode=False, name=None, exclusive=True, data_format=“NCHW”)设置pool_type=“max”

  • torch.nn.functional.max_pool3d fluid.layers.pool3d(input, pool_size=-1, pool_type=“max”, pool_stride=1, pool_padding=0, global_pooling=False, use_cudnn=True, ceil_mode=False, name=None, exclusive=True, data_format=“NCDHW”)设置pool_type=“max”

  • torch.nn.functional.mse_loss fluid.layers.mse_loss(input, label)

  • torch.nn.functional.one_hot fluid.one_hot

  • torch.nn.functional.pad fluid.layers.pad(x, paddings, pad_value=0.0, name=None)

  • torch.nn.functional.pixel_shuffle fluid.layers.pixel_shuffle(x, upscale_factor)

  • torch.nn.functional.prelu fluid.layers.prelu(x, mode, param_attr=None, name=None)

  • torch.nn.functional.relu fluid.layers.relu(x, name=None)

  • torch.nn.functional.relu6 fluid.layers.relu6

  • torch.nn.functional.selu fluid.layers.selu

  • torch.nn.functional.sigmoid fluid.layers.sigmoid

  • torch.nn.functional.smooth_l1_loss fluid.layers.smooth_l1(x, y, inside_weight=None, outside_weight=None, sigma=None)

  • torch.nn.functional.softmax fluid.layers.softmax

  • torch.nn.functional.softplus fluid.layers.softplus

  • torch.nn.functional.softshrink fluid.layers.softshrink

  • torch.nn.functional.softsign fluid.layers.softsign

  • torch.nn.functional.tanh fluid.layers.tanh

  • torch.nn.functional.tanhshrink fluid.layers.tanh_shrink

  • torch.nn.functional.threshold fluid.layers.thresholded_relu

  • torch.nn.functional.unfold fluid.layers.unfold(x, kernel_size, strides=1, paddings=0, dilation=1, name=None)

  • torch.nn.GroupNorm fluid.layers.group_norm(input, groups, epsilon=1e-05, param_attr=None, bias_attr=None, act=None, data_layout=‘NCHW’, name=None)

  • torch.nn.GRU fluid.layers.dynamic_gru

  • torch.nn.GRUCell fluid.layers.GRUCell

  • torch.nn.half fluid.layers.cast(x, dtype)

  • torch.nn.Hardshrink fluid.layers.hard_shrink(x, threshold=None)

  • torch.nn.init.constant_ fluid.initializer.ConstantInitializer(value=0.0, force_cpu=False)

  • torch.nn.init.eye_ fluid.layers.eye(num_rows, num_columns=None, batch_shape=None, dtype=‘float32’)

  • torch.nn.init.kaimingnormal fluid.initializer.MSRAInitializer(uniform=True, fan_in=None, seed=0)

  • torch.nn.init.kaiminguniform fluid.initializer.MSRAInitializer(uniform=True, fan_in=None, seed=0)

  • torch.nn.init.normal_ fluid.initializer.NormalInitializer(loc=0.0, scale=1.0, seed=0)

  • torch.nn.init.ones_ fluid.layers.ones(shape, dtype, force_cpu=False)

  • torch.nn.init.uniform_ fluid.initializer.UniformInitializer(low=-1.0, high=1.0, seed=0)

  • torch.nn.init.xaviernormal fluid.initializer.XavierInitializer(uniform=True, fan_in=None, fan_out=None, seed=0

  • torch.nn.init.xavieruniform fluid.initializer.XavierInitializer(uniform=True, fan_in=None, fan_out=None, seed=0

  • torch.nn.init.zeros_ fluid.layers.zeros(shape, dtype, force_cpu=False)

  • torch.nn.InstanceNorm1d fluid.layers.instance_norm

  • torch.nn.InstanceNorm2d fluid.layers.instance_norm

  • torch.nn.InstanceNorm3d fluid.layers.instance_norm

  • torch.nn.LayerNorm fluid.layers.layer_norm(input, scale=True, shift=True, begin_norm_axis=1, epsilon=1e-05, param_attr=None, bias_attr=None, act=None, name=None)

  • torch.nn.LeakyReLU fluid.layers.leaky_relu(x, alpha=0.02, name=None)

  • torch.nn.Linear fluid.dygraph.Linear(input_dim, output_dim, param_attr=None, bias_attr=None, act=None, dtype=‘float32’)

  • torch.nn.load_state_dict fluid.dygraph.Layer.set_dict(stat_dict, include_sublayers=True)

  • torch.nn.LogSigmoid fluid.layers.logsigmoid(x, name=None)

  • torch.nn.LSTM fluid.layers.lstm

  • torch.nn.LSTMCell fluid.layers.LSTMCell

  • torch.nn.MarginRankingLoss fluid.layers.margin_rank_loss(label, left, right, margin=0.1, name=None)

  • torch.nn.MaxPool2d fluid.layers.pool2d(pool_type为’max’)

  • torch.nn.MaxPool3d fluid.layers.pool3d(pool_type为’max’)

  • torch.nn.Module fluid.dygraph.Layer()

  • torch.nn.modules fluid.dygraph.Layer.sublayers(include_sublayers=True)

  • torch.nn.MSELoss fluid.dygraph.MSELoss(input, label)

  • torch.nn.MultiheadAttention fluid.nets.scaled_dot_product_attention

  • torch.nn.named_modules fluid.dygraph.Layer.named_sublayers(prefix=’’,include_sublayers=True,include_self=False,layers_set=None)

  • torch.nn.named_parameters fluid.dygraph.Layer.named_parameters(prefix=’’, include_sublayers=True)

  • torch.nn.ParameterList fluid.dygraph.ParameterList

  • torch.nn.parameters fluid.dygraph.Layer.parameters(include_sublayers=True)

  • torch.nn.PixelShuffle fluid.layers.pixel_shuffle

  • torch.nn.PReLU fluid.dygraph.Prelu

  • torch.nn.ReflectionPad2d fluid.layers.pad2d

  • torch.nn.register_parameter fluid.dygraph.Layer.add_parameter(name, parameter)

  • torch.nn.ReLU fluid.layers.relu(x, name=None)

  • torch.nn.ReLU6 fluid.layers.relu6

  • torch.nn.ReplicationPad2d fluid.layers.pad2d

  • torch.nn.requiresgrad fluid.Variable().stop_gradient

  • torch.nn.RNN fluid.layers.rnn

  • torch.nn.RNNCell fluid.layers.RNNCell

  • torch.nn.SELU fluid.layers.selu

  • torch.nn.Sequential fluid.dygraph.Sequential(*layers)

  • torch.nn.Sigmoid fluid.layers.sigmoid(x, name=None)

  • torch.nn.SmoothL1Loss fluid.layers.smooth_l1(x, y, inside_weight=None, outside_weight=None, sigma=None)

  • torch.nn.Softmax fluid.layers.softmax(input, use_cudnn=False, name=None, axis=-1)

  • torch.nn.Softplus fluid.layers.softplus

  • torch.nn.Softshrink fluid.layers.softshrink(x, alpha=None)

  • torch.nn.Softsign fluid.layers.softsign(x, name=None)

  • torch.nn.state_dict fluid.dygraph.Layer.state_dict

  • torch.nn.Tanh fluid.layers.tanh(x, name=None)

  • torch.nn.Tanhshrink fluid.layers.tanh_shrin

  • torch.nn.Threshold fluid.layers.thresholded_relu(x, threshold=None)

  • torch.nn.train fluid.dygraph.Layer.train()

  • torch.nn.type fluid.layers.cast(x, dtype)

  • torch.nn.UpsamplingBilinear2d fluid.layers.resize_bilinear

  • torch.nn.UpsamplingNearest2d fluid.layers.resize_nearest

  • torch.nn.zero_grad fluid.dygraph.Layer.clear_gradients()

  • torch.nn.ZeroPad2d fluid.layers.pad / fluid.layers.pad2d

  • torch.norm fluid.layers.l2_normalize

  • torch.normal fluid.layers.gaussian_random(shape, mean=0.0, std=1.0, seed=0, dtype=‘float32’)

  • torch.numel fluid.layers.size(input)

  • torch.ones fluid.layers.ones

  • torch.ones_like fluid.layers.ones_like

  • torch.pow fluid.layers.pow

  • torch.prod fluid.layers.reduce_prod(input, dim=None, keep_dim=False, name=None)

  • torch.rand_like fluid.layers.gaussian_random_batch_size_like(input, shape, input_dim_idx=0, output_dim_idx=0, mean=0.0, std=1.0, seed=0, dtype=‘float32’)[

  • torch.randint fluid.layers.randint(low, high=None, shape=None, out=None, dtype=None, device=None, stop_gradient=False, seed=0, name=None)

  • torch.randn fluid.layers.randn

  • torch.randn_like fluid.layers.gaussian_random_batch_size_like

  • torch.randperm fluid.layers.randperm

  • torch.range fluid.layers.range

  • torch.reciprocal fluid.layers.reciprocal(x, name=None)

  • torch.reshape fluid.layers.reshape(x, shape, actual_shape=None, act=None, inplace=False, name=None)

  • torch.roll fluid.layers.roll

  • torch.round fluid.layers.round(x, name=None)

  • torch.rsqrt fluid.layers.rsqrt(x, name=None)

  • torch.seed fluid.Program.random_seed

  • torch.set_num_interop_threads fluid.ExecutionStrategy.num_threads

  • torch.set_num_threads fluid.cpu_places(device_count=None)

  • torch.sigmoid fluid.layers.sigmoid(x, name=None)

  • torch.sign fluid.layers.sign(x)

  • torch.sin fluid.layers.sin(x, name=None)

  • torch.split fluid.layers.split(input, num_or_sections, dim=-1, name=None)

  • torch.sqrt fluid.layers.squeeze(input, axes, name=None)

  • torch.squeeze fluid.layers.squeeze(input, axes, name=None)

  • torch.stack fluid.layers.stack(x, axis=0)

  • torch.std_mean fluid.layers.mean

  • torch.sum fluid.layers.sum(x)

  • torch.sum fluid.layers.elementwise_add(x, y, axis=-1, act=None, name=None)

  • torch.tan fluid.layers.tanh(x, name=None)

  • torch.tanh fluid.layers.tanh(x, name=None)

  • torch.Tensor.abs fluid.layers.abs(x, name=None)

  • torch.Tensor.abs_ fluid.layers.abs(x, name=None)

  • torch.Tensor.acos fluid.layers.acos(x, name=None)

  • torch.Tensor.acos_ fluid.layers.acos(x, name=None)

  • torch.Tensor.add_ fluid.layers.elementwise_add(x, y, axis=-1, act=None, name=None)

  • torch.Tensor.asin_ fluid.layers.asin(x, name=None)

  • torch.Tensor.atan_ fluid.layers.atan(x, name=None)

  • torch.Tensor.backward fluid.gradients(targets, inputs, target_gradients=None, no_grad_set=None)paddle 目标变量和起始

  • torch.Tensor.bfloat16 fluid.layers.cast(x, float16)

  • torch.Tensor.bmm fluid.layers.matmul

  • torch.Tensor.bool fluid.layers.cast(x, bool)

  • torch.Tensor.byte fluid.layers.cast(x, uint8)

  • torch.Tensor.ceil fluid.layers.ceil

  • torch.Tensor.clamp fluid.layers.clip

  • torch.Tensor.clamp_ fluid.layers.clip(x, min, max, name=None)

  • torch.Tensor.clone fluid.layers.assign(input, output=None)

  • torch.Tensor.cos fluid.layers.cos

  • torch.Tensor.cumsum fluid.layers.cumsum

  • torch.Tensor.dequantize fluid.layers.dequantize()

  • torch.Tensor.diag fluid.layers.diag

  • torch.Tensor.div fluid.layers.elementwise_div(x, y, axis=-1, act=None, name=None)

  • torch.Tensor.eq fluid.layers.equal

  • torch.Tensor.eq_ fluid.layers.equal(x, y, cond=None)

  • torch.Tensor.exp fluid.layers.exp(x, name=None)

  • torch.Tensor.exp_ fluid.layers.exp(x, name=None)

  • torch.Tensor.expand fluid.layers.expand(x, expand_times, name=None)

  • torch.Tensor.expand_as fluid.layers.expand_as(x, target_tensor, name=None)

  • torch.Tensor.filldiagonal fluid.layers.diag(diagonal)

  • torch.Tensor.flatten fluid.layers.flatten

  • torch.Tensor.flip fluid.layers.reverse

  • torch.Tensor.floor fluid.layers.floor

  • torch.Tensor.floor_ fluid.layers.floor(x, name=None)

  • torch.Tensor.fmod_ fluid.layers.elementwise_mod(x, y, axis=-1, act=None, name=None)

  • torch.Tensor.gather fluid.layers.gather(input, index, overwrite=True)

  • torch.Tensor.ge fluid.layers.greater_equal(x, y, cond=None)

  • torch.Tensor.ge_ fluid.layers.greater_equal(x, y, cond=None)

  • torch.Tensor.gt fluid.layers.greater_than(x, y, cond=None)

  • torch.Tensor.gt_ fluid.layers.greater_than(x, y, cond=None)

  • torch.Tensor.hardshrink fluid.layers.hard_shrink(x, threshold=None)

  • torch.Tensor.index_select fluid.layers.multiplex(inputs, index)

  • torch.Tensor.int fluid.layers.cast

  • torch.Tensor.le fluid.layers.less_equal(x, y, cond=None)

  • torch.Tensor.le_ fluid.layers.less_equal(x, y, cond=None)

  • torch.Tensor.log fluid.layers.log(x, name=None)

  • torch.Tensor.log_ fluid.layers.log(x, name=None)

  • torch.Tensor.logical_not fluid.layers.logical_not(x, out=None, name=None)

  • torch.Tensor.logicalnot fluid.layers.logical_not(x, out=None, name=None)

  • torch.Tensor.logical_xor fluid.layers.logical_xor(x, y, out=None, name=None)

  • torch.Tensor.logicalxor fluid.layers.logical_xor(x, y, out=None, name=None)

  • torch.Tensor.lt fluid.layers.less_than(x, y, cond=None)

  • torch.Tensor.lt_ fluid.layers.less_than(x, y, force_cpu=None, cond=None)

  • torch.Tensor.masked_select fluid.layers.masked_select(input, mask)

  • torch.Tensor.matmul fluid.layers.matmul(x, y, transpose_x=False, transpose_y=False, alpha=1.0, name=None)

  • torch.Tensor.matrix_power fluid.layers.pow(x, factor=1.0, name=None)

  • torch.Tensor.max fluid.layers.reduce_max(input, dim=None, keep_dim=False, name=None)

  • torch.Tensor.mean fluid.layers.mean(x, name=None)

  • torch.Tensor.min "fluid.layers.reduce_min(input, dim=None, keep_dim=False, name=None) "

  • torch.Tensor.mul fluid.layers.mul(x, y, x_num_col_dims=1, y_num_col_dims=1, name=None)

  • torch.Tensor.mul_ fluid.layers.mul(x, y, x_num_col_dims=1, y_num_col_dims=1, name=None)

  • torch.Tensor.multinomial fluid.layers.sampling_id(x, min=0.0, max=1.0, seed=0, dtype=‘float32’)

  • torch.Tensor.mv fluid.layers.mul(x, y, x_num_col_dims=1, y_num_col_dims=1, name=None)

  • torch.Tensor.narrow_copy fluid.layers.slice(input, axes, starts, ends)

  • torch.Tensor.ndimension fluid.layers.rank(input)

  • torch.Tensor.ne_ fluid.layers.not_equal(x, y, cond=None)

  • torch.Tensor.normal_ fluid.layers.Normal(loc, scale)

  • torch.Tensor.numel fluid.layers.size(input)

  • torch.Tensor.permute fluid.layers.transpose(x, perm, name=None)

  • torch.Tensor.pow fluid.layers.pow(x, factor=1.0, name=None)

  • torch.Tensor.pow_ fluid.layers.pow(x, factor=1.0, name=None)

  • torch.Tensor.prod fluid.layers.reduce_prod(input, dim=None, keep_dim=False, name=None)[

  • torch.Tensor.put_ fluid.layers.scatter(input, index, updates, name=None, overwrite=True)[源代码]

  • torch.Tensor.random_ fluid.layers.uniform_random(shape, dtype=‘float32’, min=-1.0, max=1.0, seed=0)

  • torch.Tensor.reciprocal fluid.layers.reciprocal(x, name=None)

  • torch.Tensor.reciprocal_ fluid.layers.reciprocal(x, name=None)

  • torch.Tensor.remainder_ fluid.layers.elementwise_mod(x, y, axis=-1, act=None, name=None)

  • torch.Tensor.requires_grad fluid.Variable.stop_gradient(属性)

  • torch.Tensor.requiresgrad fluid.Variable.stop_gradient(属性)

  • torch.Tensor.reshape fluid.layers.reshape(x, shape, actual_shape=None, act=None, inplace=False, name=None)

  • torch.Tensor.reshape_as fluid.layers.reshape(x, shape, actual_shape=None, act=None, inplace=False, name=None)

  • torch.Tensor.resizeas fluid.layers.reshape(x, shape, actual_shape=None, act=None, inplace=False, name=None)

  • torch.Tensor.round fluid.layers.round(x, name=None)

  • torch.Tensor.round_ fluid.layers.round(x, name=None)

  • torch.Tensor.rsqrt fluid.layers.rsqrt(x, name=None)

  • torch.Tensor.rsqrt_ fluid.layers.rsqrt(x, name=None)

  • torch.Tensor.scatter fluid.layers.scatter(input, index, updates, name=None, overwrite=True)

  • torch.Tensor.scatter_ fluid.layers.scatter(input, index, updates, name=None, overwrite=True)

  • torch.Tensor.scatter_add fluid.layers.scatter(input, index, updates, name=None, overwrite=True)

  • torch.Tensor.scatteradd fluid.layers.scatter(input, index, updates, name=None, overwrite=True)

  • torch.Tensor.select fluid.layers.slice

  • torch.Tensor.short fluid.layers.cast(x, dtype)

  • torch.Tensor.sigmoid fluid.layers.sigmoid(x, name=None)

  • torch.Tensor.sigmoid_ fluid.layers.sigmoid(x, name=None)

  • torch.Tensor.sign fluid.layers.sign(x)

  • torch.Tensor.sign_ fluid.layers.sign(x)

  • torch.Tensor.sin fluid.layers.sin(x, name=None)

  • torch.Tensor.sin_ fluid.layers.sin(x, name=None)

  • torch.Tensor.split fluid.layers.split(input, num_or_sections, dim=-1, name=None)

  • torch.Tensor.sqrt fluid.layers.sqrt(x, name=None)

  • torch.Tensor.sqrt_ fluid.layers.sqrt(x, name=None)

  • torch.Tensor.squeeze fluid.layers.squeeze(input, axes, name=None)

  • torch.Tensor.squeeze_ fluid.layers.squeeze(input, axes, name=None)

  • torch.Tensor.sub fluid.layers.elementwise_sub(x, y, axis=-1, act=None, name=None)

  • torch.Tensor.sub_ fluid.layers.elementwise_sub(x, y, axis=-1, act=None, name=None)

  • torch.Tensor.sum fluid.layers.sum(x)

  • torch.Tensor.t_ fluid.layers.transpose(x, perm, name=None)

  • torch.Tensor.tanh fluid.layers.tanh(x, name=None)

  • torch.Tensor.tanh_ fluid.layers.tanh(x, name=None)

  • torch.Tensor.to fluid.layers.cast(x, dtype)

  • torch.Tensor.topk fluid.layers.topk(input, k, name=None)

  • torch.Tensor.transpose fluid.layers.transpose(x, perm, name=None)

  • torch.Tensor.transpose_ fluid.layers.transpose(x, perm, name=None)

  • torch.Tensor.trunc fluid.layers.floor(x, name=None)

  • torch.Tensor.unbind fluid.layers.unstack(x, axis=0, num=None)

  • torch.Tensor.unique fluid.layers.unique

  • torch.Tensor.unsqueeze fluid.layers.unsqueeze

  • torch.Tensor.unsqueeze_ fluid.layers.unsqueeze(input, axes, name=None)

  • torch.Tensor.view fluid.layers.reshape(x, shape, actual_shape=None, act=None, inplace=False, name=None)

  • torch.Tensor.where fluid.layers.where

  • torch.Tensor.zero_ fluid.layers.zeros(shape, dtype, force_cpu=False)

  • torch.topk fluid.layers.topk(input, k, name=None)

  • torch.transpose fluid.layers.transpose(x, perm, name=None)

  • torch.tril fluid.layers.tril

  • torch.triu fluid.layers.triu

  • torch.unique fluid.layers.unique(x, dtype=‘int32’)

  • torch.unsqueeze fluid.layers.unsqueeze(input, axes, name=None)

  • torch.var_mean fluid.layers.mean

  • torch.where fluid.layers.where(condition)

  • torch.zeros fluid.layers.zeros(shape, dtype, force_cpu=False)

  • torch.zeros_like fluid.layers.zeros_like(x, out=None)

  • torch.utils.data.dataloader.default_collate fluid.io.default_collate_fn

  • torch.optim.lr_scheduler.StepLR fluid.dygraph.StepDecay

  • torch.clamp fluid.layers.clip

  • torch.meshgrid fluid.layers.meshgrid

  • torch.view fluid.layers.reshape

  • torch.repeat fluid.layers.expand

  • torch.from_numpy fluid.dygraph.to_variable

  • torch.type_as fluid.layers.cast

· One min read

torch.meshgrid（）

import torch
a = torch.tensor([1, 2, 3, 4])
print(a)
b = torch.tensor([4, 5, 6])
print(b)
x, y = torch.meshgrid(a, b)
print(x)
print(y)
 
结果显示：
tensor([1, 2, 3, 4])
tensor([4, 5, 6])
tensor([[1, 1, 1],
        [2, 2, 2],
        [3, 3, 3],
        [4, 4, 4]])
tensor([[4, 5, 6],
        [4, 5, 6],
        [4, 5, 6],
        [4, 5, 6]])
 
 
 
# 【2】
import torch
a = torch.tensor([1, 2, 3, 4, 5, 6])
print(a)
b = torch.tensor([7, 8, 9, 10])
print(b)
x, y = torch.meshgrid(a, b)
print(x)
print(y)
 
结果显示：
tensor([1, 2, 3, 4, 5, 6])
tensor([ 7,  8,  9, 10])
tensor([[1, 1, 1, 1],
        [2, 2, 2, 2],
        [3, 3, 3, 3],
        [4, 4, 4, 4],
        [5, 5, 5, 5],
        [6, 6, 6, 6]])
tensor([[ 7,  8,  9, 10],
        [ 7,  8,  9, 10],
        [ 7,  8,  9, 10],
        [ 7,  8,  9, 10],
        [ 7,  8,  9, 10],
        [ 7,  8,  9, 10]])

两个矩阵相乘得x_Transpose * y

· 2 min read

assert()断言函数，用于在调试过程中捕捉程序错误

void assert (int expression);

断言函数，用于在调试过程中捕捉程序的错误。

“断言”在语文中的意思是“断定”、“十分肯定地说”，在编程中是指对某种假设条件进行检测，如果条件成立就不进行任何操作，如果条件不成立就捕捉到这种错误，并打印出错误信息，终止程序执行。

assert() 会对表达式expression进行检测：

  • 如果expression的结果为 0（条件不成立），那么断言失败，表明程序出错，assert() 会向标准输出设备（一般是显示器）打印一条错误信息，并调用 abort() 函数终止程序的执行。
  • 如果expression的结果为非 0（条件成立），那么断言成功，表明程序正确，assert() 不进行任何操作。

要打印的错误信息的格式和内容没有统一的规定，这和标准库的具体实现有关（也可以说和编译器有关），但是错误信息至少应该包含以下几个方面的信息：

  • 断言失败的表达式，也即expression；
  • 源文件名称；
  • 断言失败的代码的行号。

大部分编译器的格式如下所示：

Assertion failed: expression, file filename, line number

其实就是一个判断，如果判断为假，运行就会停止，并报一个判断错误。

· 3 min read

色彩抖动

这篇的开始，我们得重温一下数字图像的记录方式。将光从最暗到最亮进行量化，然后用正整数来记录，是数字图像的最核心的记录原理。但其中会引发一个思考，自然光的明暗渐变是无限光滑的，而24位图像的红绿蓝三色光，每种的渐变层数最多256级，那么会不会丢失细节？答案是明确的，细节一定会丢失。未来如果能普及48位图像，那么每一种原色光的记录级数可以达到65536级，将有巨大的进步，但它依然无法实现自然光无限光滑的效果。未来科技进一步发达，如果出现192位的图像，它能够做到的是将记录层次记录得更细密，更加接近无限光滑，但始终难以实现真正意义上的无限光滑。

问题出现，如果记录一个介于整数A和B之间的颜色时，该怎么办？假设A是255，B是254，它们之间不可能再出现一个整数，这个记录将无法进行。此时，我们需要开始了解“色彩的抖动”了。

因为人眼的分辨率是有限的，当两种颜色混杂在一起，且超过人眼能处理的分辨率范围时，人眼会自动将两种颜色混合

image-20220615213422606

所以可以用比较少的颜色来表示更多的颜色

关于颜色抖动数据增强​

色彩抖动是通过随机调整原始图片的饱和度，亮度，对比度来对产生新的图像，增加数据集

· One min read

vscode 环境配置

c/c++和python的基本配置还是很简单的

c/c++：https://zhuanlan.zhihu.com/p/87864677

python: https://zhuanlan.zhihu.com/p/64994681

好吧，有必要更新一下

首先，c文件是不能运行cpp的

然后，vscode本身并不是编译完c文件以后就自动运行的。

是需要把launch.json中的"externalConsole": false改为"externalConsole": true即可。

同时有可能遇到中文乱码问题

image-20220620220636678

· One min read

test

测试图床

Screenshot_20210807_095541_e24760d1d02f1ef481aac8

· 2 min read

cutmix

Mixup、Cutout和CutMix三种数据增强方法 作者在论文中对比了三种数据增强的方法：Mixup,Cutout和CutMix在数据集中的性能。通过观察下图可以发现，CutMix在填充了训练集中的其他照片的同时，label也进行了相同比例转换。

image-20220615215236214 CutMix最大程度的利用了同一张图像上的两种不同图像信息。具有更好的分类性能和目标定位功能。

保证在一幅图像中从局部视角上识别出两个目标，提高了训练效率。为了验证CutMix确实学习去识别两个目标，作者对CutMix、Cutout和Mixup进行了比较。通过观察下面的实验结果可以发现，CutMix能够精准的定位两个类别目标。

image-20220615215332616

· 4 min read

Jupyter notebook中你所不知道的快捷键

Jupyter Notebook是数据科学家最重要的工具之一。这款工具很容易上手，但是你可能不知道它有强大的快捷键功能，可以大大加快你的开发效率。本文将介绍在MacBook中的快捷键操作。Windows用户和本文中的操作会略有不同。

快捷键分为*命令模式（Command Mode*）和*编辑模式(Edit Mode)*。命令模式操作到对象是单元格（cell）。也就是可以对单元格进行插入删除等操作。当在命令模式的时候，单元格左侧的颜色是蓝色的。

img

当切换到编辑模式到时候，操作的是单元格中的文本和代码。单元格左侧的颜色会变成绿色，如下图：

img

下面我们将对这些快捷键进行详细的介绍。

命令模式：

  1. Esc + H: 当你忘记快捷键的时候可以使用快捷键找到快捷键列表。

imgESC +H：快捷键列表

Esc + P：打开命令面板(Command Palette)是另一种找到命令的办法。

imgESC + P：打开命令面板

\2. Enter（回车）：切换到编辑模式。

Esc：切换到命令模式

\3. Esc + M：将单元格切换到markdown模式。这种模式你可以编辑标题和图片等。

Esc + Y：将单元格切换到代码模式，写代码。

Esc + R：将单元格切换到非markdown的文本编辑模式。

\4. Shift + enter：运行当前单元格的内容，选中下一个单元格的内容。光标会进入下一个单元格。

Ctrl + enter: 运行当前内容，光标保留在当前单元格。

\5. Ecs + 1：单元格切换为markdown中的标题一。Esc + 1，2，3，4，5分别对应不同级别的标题。

\6. Esc + A：在单元格上方插入单元格。

Esc + B：在单元格下方插入单元格。

Esc + X：剪切单元格。

Esc + C：复制单元格。

Esc + V: 粘贴单元格。

Esc + Z：撤销删除单元格。

Esc + D：删除单元格。

\7. Esc + Shift + ⬆️：选中本单元格和上侧的单元格。

Esc + Shift + ⬇️：选中本单元格和下侧的单元格。

\8. Esc + Shift + M：合并（merge）选中的单元格。

\9. Esc + 空格：下滚页面。

Esc + Shift + 空格: 上滚页面。

编辑模式：

本文的实验在MacBook中完成，Command键对应windows电脑中的ctrl键。

  1. Command + ]：向右缩进。

Command + [：向左缩进。

\2. Command + z： 撤销。

Command + Shift + z: 还原。

\3. Command + ⬅️：回到行首。

Command + ➡️：到行尾。

\4. option + ⬅️：向左移动一个词的距离。

option + ➡️：向右移动一个词的距离。

\5. option + 左删除：删除左侧一个词。

option + 右删除：删除右侧一个词。

\6. Command + s：保存。

以上就是常用的快捷操作，练习几次一定会大大提高开发效率。

· 11 min read

什么是面向对象编程 1、面向对象编程(oop)是一种程序设计思想。oop把对象作为程序的基本单元，一个对象包含数据和操作数据的函数

2、在python中，所有数据类型都被视为对象，也可以自定义对象。自定义对象数据类型就是面向对象中类的概念

面向对象术语简介 1、类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例

2、方法：类中定义的函数

3、类变量(属性)：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体(方法)之外。类变量通常不作为实例变量使用，类变量也称作属性

4、数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据

5、方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写

6、实例变量：定义在init方法中的变量，只作用于当前实例的类

7、继承：即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待,以普通的类为基础建立专门的类对象

8、实例化：创建一个类的实例，类的具体对象。一个类可以实例化出无数个对象

9、对象：通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法

10、多态：对不同类的对象使用同样的操作

11、封装：对外部世界隐藏对象的工作细节

Python类 1、类提供了一种组合数据和功能的方法。创建一个新类意味着创建一个新的对象类型，从而允许创建一个该类型的新实例

2、每个类的实例可以拥有保存自己状态的属性。一个类的实例也可以有改变自己状态的（定义在类中的）方法

3、Python的类提供了面向对象编程的所有标准特性： ⑴类继承机制允许多个基类，派生类可以覆盖它基类的任何方法，一个方法可以调用基类中相同名称的的方法 ⑵对象可以包含任意数量和类型的数据 ⑶和模块一样，类也拥有Python天然的动态特性：它们在运行时创建，可以在创建后修改

Python类的定义 1、python中定义类使用class关键字，class后面紧接类名，类名通常是大写开头的单词(无类继承时类名后可以加括号也可以不加括号)

2、python中类的定义语法如下：

class ClassName:
    语句1
    ...
    语句n

注： 1、类定义与函数定义(def语句)一样：只有在被执行才会起作用 ⑴在定义阶段只是语法检查

2、类是属性和方法的组合，所以语句1可能是内部变量(数据、属性)的定义和赋值语句，也可能是内部方法(函数)的定义语句 ⑴一个对象的特征称为"属性" ⑵一个对象的行为称为"方法" ⑶属性在代码层面上来看就是变量，方法实际就是函数，通过调用这些函数来完成某些工作

3、进入类定义时，就会创建一个新的命名空间，并把它用作局部作用域 ⑴因此，所有对局部变量的赋值都是在这个新命名空间内进行的。特别的，函数定义会绑定到这个局部作用域里的新函数名称

4、正常离开(从结尾出)类定义时，就会创建一个类对象 ⑴它基本上是一个包围在类定义所创建的命名空间内容周围的包装器 ⑵元素的(在进入类定义之前起作用的)局部作用域将重新生效，类对象将在这里被绑定到类定义头给出的类名称(在上面的例子中就是ClassName)


class MyClass:
    """定义一个MyClass类"""
    i = 12345
 
    def func(self):
        return 'hello world'

注： 1、类包含属性和方法 ⑴属性：分为类属性和实例属性 ①"i = 12345"：表示定义了一个类属性i其值为12345(实例属性后面介绍) ⑵方法：即定义在类中的函数(与普通的函数类似) ②func：表示定义了一个名为func的实例方法，实际上就是一个稍微特殊点的函数(方法的第一个参数必须为self)

2、在类中定义方法的形式和函数差不多，但其不称为函数，而是叫方法。方法的调用需要绑定到特定的对象上(通过self.或实例对象名)，而函数不需要 ⑴类内部的函数定义通常具有一种特别形式的参数列表，这个特别形式就是第一个参数必须是self(self参数后面介绍) ⑵方法是所有实例都共用的：类外所有实例都可以调用类中的方法，类中方法之间也可以相互调用

3、上面例子中创建了一个MyClass抽象类，定义好类后会在当前作用域定义名字MyClass，指向类对象MyClass

4、类也是一种对象类型，跟前面学习过的数值、字符串、列表等等是一样的 ⑴比如这里构建的类名字叫做MyClass，那么就是我们要试图建立一种对象类型，这种类型被称之为MyClass，就如同有一种对象类型是list一样

5、Python中一切皆对象。不管是我们自己定义的类、6种基本数据类型还是内置的类(第三方类)等都称作为对象 ⑴一个对象，就会拥有自己的属性和方法。我们可以通过一定的方式来调用一个对象的属性和方法。这一点自定义类与其他Python类型是一样的

6、Python类中的方法分为：实例方法、类方法、静态方法。这里主要介绍实例方法(方法中第一个参数必须为self)，感觉其他两种方法用的比较少

类对象 1、类是抽象的概念，它是一种数据结构：就好比一个模型，该模型是生活中具有相同属性(特征)和方法(动作)的同一类事务，可以用它来生产真实的物体(实例) ⑴在python中，把具有相同属性和方法的对象归为一个类(class)

2、比如，我们可以将类看做是一个"饼干模具"，这个模具上有一些饼干的特征(属性)和行为(方法) ⑴有了这个模具之后我们就可以通过这个模块来制作很多具有相同属性和行为的不同饼干了(制作出来的肯定不是同一块饼干)

3、定义一个类后，就相当于有了一个类对象了：Python中"一切皆对象"。类也称为"类对象" ⑴比如前面例1中定义了类MyClass，其也可以成为类对象

4、类对象支持两种操作：属性引用和实例化 ⑴实例化：使用instance_name = class_name()的方式实例化，实例化操作创建该类的实例(格式：实例对象名 = 类名()，实例对象名是我们自己定义的) ⑵属性引用：使用class_name.attr_name的方式引用类属性(类名.属性名)

​ 大概前半段就能对类有一个比较清楚的理解，具体用法还是看原帖吧，感觉没必要进行重述了。

转载自(86条消息) python：类基础_不怕猫的耗子A的博客-CSDN博客_python 类