def sync_random_Horizontal_Flip(input_images, target_images):
'''
Randomly flip the input images and the target images.
'''
seed = np.random.randint(0, 2000000000)
mindspore.set_seed(seed)
op = C.RandomHorizontalFlip(prob=0.5)
out_input = op(input_images)
mindspore.set_seed(seed)
op = C.RandomHorizontalFlip(prob=0.5)
out_target = op(target_images)
return out_input, out_target
def test_char_encoder(self):
context.set_context(mode=context.PYNATIVE_MODE, device_target='Ascend')
mindspore.set_seed(1)
weights = Tensor(np.random.randint(0, 9, [7, 10]), mindspore.float32)
biases = Tensor(np.random.randint(0, 9, [7]), mindspore.float32)
labels = Tensor([0, 1, 2])
inputs = Tensor(np.random.randint(0, 9, [3, 10]), mindspore.float32)
loss = SampledSoftmaxLoss(num_sampled=4,
num_classes=7,
num_true=1,
seed=1)
output = loss(weights, biases, labels, inputs)
assert output.shape == labels.shape
from mindspore.context import ParallelMode
from mindspore.train.serialization import load_checkpoint, load_param_into_net
from src.unet import UNet
from src.data_loader import create_dataset
from src.loss import CrossEntropyWithLogits
from src.utils import StepLossTimeMonitor
from src.config import cfg_unet
device_id = int(os.getenv('DEVICE_ID'))
context.set_context(mode=context.GRAPH_MODE,
device_target="Ascend",
save_graphs=False,
device_id=device_id)
mindspore.set_seed(1)
def train_net(data_dir,
cross_valid_ind=1,
epochs=400,
batch_size=16,
lr=0.0001,
run_distribute=False,
cfg=None):
if run_distribute:
init()
group_size = get_group_size()
parallel_mode = ParallelMode.DATA_PARALLEL
context.set_auto_parallel_context(parallel_mode=parallel_mode,
def test_resnet50_quant():
set_seed(1)
context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
config = config_quant
print("training configure: {}".format(config))
epoch_size = config.epoch_size
# define network
net = resnet50_quant(class_num=config.class_num)
net.set_train(True)
# define loss
if not config.use_label_smooth:
config.label_smooth_factor = 0.0
loss = CrossEntropy(smooth_factor=config.label_smooth_factor,
num_classes=config.class_num)
#loss_scale = FixedLossScaleManager(config.loss_scale, drop_overflow_update=False)
# define dataset
dataset = create_dataset(dataset_path=dataset_path,
config=config,
repeat_num=1,
batch_size=config.batch_size)
step_size = dataset.get_dataset_size()
# convert fusion network to quantization aware network
net = quant.convert_quant_network(net,
bn_fold=True,
per_channel=[True, False],
symmetric=[True, False])
# get learning rate
lr = Tensor(
get_lr(lr_init=config.lr_init,
lr_end=0.0,
lr_max=config.lr_max,
warmup_epochs=config.warmup_epochs,
total_epochs=config.epoch_size,
steps_per_epoch=step_size,
lr_decay_mode='cosine'))
# define optimization
opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), lr,
config.momentum, config.weight_decay, config.loss_scale)
# define model
#model = Model(net, loss_fn=loss, optimizer=opt, loss_scale_manager=loss_scale, metrics={'acc'})
model = Model(net, loss_fn=loss, optimizer=opt)
print("============== Starting Training ==============")
monitor = Monitor(lr_init=lr.asnumpy(),
step_threshold=config.step_threshold)
callbacks = [monitor]
model.train(epoch_size,
dataset,
callbacks=callbacks,
dataset_sink_mode=False)
print("============== End Training ==============")
expect_avg_step_loss = 2.40
avg_step_loss = np.mean(np.array(monitor.losses))
print("average step loss:{}".format(avg_step_loss))
assert avg_step_loss < expect_avg_step_loss
eval_ckpt_step=args_opt.eval_ckpt_step,
save_ckpt_dir=save_ckpt_dir,
embedding_bits=student_net_cfg.embedding_bits,
weight_bits=student_net_cfg.weight_bits,
clip_value=student_net_cfg.weight_clip_value,
metrics=task.metrics)
]
else:
callback = [
StepCallBack(),
ModelSaveCkpt(network=netwithloss.bert,
save_ckpt_step=args_opt.save_ckpt_step,
max_ckpt_num=args_opt.max_ckpt_num,
output_dir=save_ckpt_dir,
embedding_bits=student_net_cfg.embedding_bits,
weight_bits=student_net_cfg.weight_bits,
clip_value=student_net_cfg.weight_clip_value)
]
model = Model(netwithgrads)
model.train(repeat_count,
train_dataset,
callbacks=callback,
dataset_sink_mode=(args_opt.enable_data_sink == 'true'),
sink_size=args_opt.data_sink_steps)
if __name__ == '__main__':
args = parse_args()
set_seed(args.seed)
run_task_distill(args)
def learn(self, data, columns=None, **kwargs):
"""Set up and run the Gran-DAG algorithm
Parameters
----------
data: numpy.ndarray or Tensor
include Tensor.data
columns : Index or array-like
Column labels to use for resulting tensor. Will default to
RangeIndex (0, 1, 2, ..., n) if no column labels are provided.
"""
# Control as much randomness as possible
set_seed(self.random_seed)
# set context for running environment
context.set_context(mode=context.PYNATIVE_MODE)
devices_list = ['CPU', 'GPU', 'Ascend']
if self.device_type.lower() == 'ascend':
self.device_type = 'Ascend'
else:
self.device_type = self.device_type.upper()
if self.device_type not in devices_list:
raise ValueError("Only support 'CPU', 'GPU' and 'Ascend'.")
context.set_context(device_target=self.device_type,
device_id=self.device_ids)
# create learning model and ground truth model
data = Tensor(data, columns=columns)
if data.shape[1] != self.input_dim:
raise ValueError("The number of variables is `{}`, "
"the param input_dim is `{}`, "
"they must be consistent.".format(
data.shape[1], self.input_dim))
if self.model_name == "NonLinGauss":
self.model = NonlinearGauss(input_dim=self.input_dim,
hidden_num=self.hidden_num,
hidden_dim=self.hidden_dim,
output_dim=self.OUT_DIM,
mu=self.mu,
lamb=self.lamb,
nonlinear=self.nonlinear,
norm_prod=self.norm_prod,
square_prod=self.square_prod)
elif self.model_name == "NonLinGaussANM":
self.model = NonlinearGaussANM(input_dim=self.input_dim,
hidden_num=self.hidden_num,
hidden_dim=self.hidden_dim,
output_dim=self.OUT_DIM_ANM,
mu=self.mu,
lamb=self.lamb,
nonlinear=self.nonlinear,
norm_prod=self.norm_prod,
square_prod=self.square_prod)
else:
raise ValueError(
"model has to be in {NonLinGauss, NonLinGaussANM}")
# create NormalizationData
train_data = NormalizationData(data,
train=True,
normalize=self.normalize)
test_data = NormalizationData(data,
train=False,
normalize=self.normalize,
mean=train_data.mean,
std=train_data.std)
# apply preliminary neighborhood selection if input_dim > 50
if self.use_pns:
if self.num_neighbors is None:
num_neighbors = self.input_dim
else:
num_neighbors = self.num_neighbors
self.model = neighbors_selection(model=self.model,
all_samples=data,
num_neighbors=num_neighbors,
thresh=self.pns_thresh)
# update self.model by train
self._train(train_data=train_data, test_data=test_data)
# get DAG by run _to_dag
self._to_dag(train_data)
self._causal_matrix = Tensor(self.model.adjacency.asnumpy(),
index=data.columns,
columns=data.columns)
def train_net(distribute, imagenet, epochs):
"""Train net"""
set_seed(1)
device_id = int(os.getenv('DEVICE_ID', '0'))
context.set_context(mode=context.GRAPH_MODE,
device_target="Ascend",
save_graphs=False,
device_id=device_id)
if imagenet == 1:
train_dataset = ImgData(args)
else:
train_dataset = data.Data(args).loader_train
if distribute:
init()
rank_id = get_rank()
rank_size = get_group_size()
parallel_mode = ParallelMode.DATA_PARALLEL
context.set_auto_parallel_context(parallel_mode=parallel_mode,
device_num=rank_size,
gradients_mean=True)
print('Rank {}, rank_size {}'.format(rank_id, rank_size))
if imagenet == 1:
train_de_dataset = ds.GeneratorDataset(
train_dataset,
["HR", "Rain", "LRx2", "LRx3", "LRx4", "scales", "filename"],
num_shards=rank_size,
shard_id=args.rank,
shuffle=True)
else:
train_de_dataset = ds.GeneratorDataset(train_dataset, ["LR", "HR"],
num_shards=rank_size,
shard_id=rank_id,
shuffle=True)
else:
if imagenet == 1:
train_de_dataset = ds.GeneratorDataset(
train_dataset,
["HR", "Rain", "LRx2", "LRx3", "LRx4", "scales", "filename"],
shuffle=True)
else:
train_de_dataset = ds.GeneratorDataset(train_dataset, ["LR", "HR"],
shuffle=True)
resize_fuc = bicubic()
train_de_dataset = train_de_dataset.project(
columns=["HR", "Rain", "LRx2", "LRx3", "LRx4", "filename"])
train_de_dataset = train_de_dataset.batch(
args.batch_size,
input_columns=["HR", "Rain", "LRx2", "LRx3", "LRx4", "filename"],
output_columns=["LR", "HR", "idx", "filename"],
drop_remainder=True,
per_batch_map=resize_fuc.forward)
train_loader = train_de_dataset.create_dict_iterator(output_numpy=True)
net_work = IPT(args)
init_weights(net_work, init_type='he', init_gain=1.0)
print("Init net weight successfully")
if args.pth_path:
param_dict = load_checkpoint(args.pth_path)
load_param_into_net(net_work, param_dict)
print("Load net weight successfully")
train_func = Trainer(args, train_loader, net_work)
for epoch in range(0, epochs):
train_func.update_learning_rate(epoch)
train_func.train()
from mindspore.profiler import Profiler
from airnetpack.model import SchNet, AirNet, MolCalculator
from airnetpack.cutoff import MollifierCutoff
from airnetpack.acsf import LogGaussianDistribution
from airnetpack.activations import ShiftedSoftplus, Swish
from airnetpack.cutoff import CosineCutoff, SmoothCutoff
from airnetpack.train import SquareLoss, AbsLoss, ForceAbsLoss, MLoss
from airnetpack.train import WithForceLossCell, WithForceEvalCell
from airnetpack.train import Recorder, MAE, MSE
if __name__ == '__main__':
# np.set_printoptions(threshold=np.inf)
seed = 1111
ms.set_seed(seed)
summary_collector = SummaryCollector(summary_dir='./summary_dir')
context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
# context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU")
# profiler = Profiler()
mol_name = 'ethanol'
train_file = './' + mol_name + '_train_1024.npz'
valid_file = './' + mol_name + '_valid_128.npz'
train_data = np.load(train_file)
valid_data = np.load(valid_file)
atomic_numbers = Tensor(train_data['z'], ms.int32)
