def get_compensate_force(raw_plan, part1_index, part2_index, model='linear'):
#Take out what we need:
raw_data_X = np.array([
raw_plan['axc_speed_%s' % args.axis_num],
raw_plan['axc_torque_ffw_gravity_%s' % args.axis_num],
raw_plan['Temp'], raw_plan['axc_pos_%s' % args.axis_num]
])
raw_data_X = np.insert(raw_data_X, 0, 1, axis=0)
raw_data_Y = raw_plan['need_to_compensate'].values
#Normalize data:
normer = data_stuff.normalizer(raw_data_X)
normed_data_X, normed_data_Y = normer.normalize_XY(raw_data_X, raw_data_Y)
#Get model:
params_part1 = get_part1_model_params(model)
params_part2 = get_part2_model_params(model)
#Forward to get output:
input = normed_data_X
if model == 'linear':
c0, c1, c2, c3, c4 = params_part1[0], params_part1[1], params_part1[
2], params_part1[3], params_part1[4]
output_part1 = classical_model.linear_friction_model(
input[:, part1_index], c0, c1, c2, c3, c4)
c0, c1, c2, c3, c4 = params_part2[0], params_part2[1], params_part2[
2], params_part2[3], params_part2[4]
output_part2 = classical_model.linear_friction_model(
input[:, part2_index], c0, c1, c2, c3, c4)
elif model == 'nonlinear':
c0, v_brk, F_brk, F_C, c1, c2, c3, c4 = params_part1[0], params_part1[
1], params_part1[2], params_part1[3], params_part1[
4], params_part1[5], params_part1[6], params_part1[7]
output_part1 = classical_model.nonlinear_friction_model(
input[:, part1_index], c0, v_brk, F_brk, F_C, c1, c2, c3, c4)
c0, v_brk, F_brk, F_C, c1, c2, c3, c4 = params_part2[0], params_part2[
1], params_part2[2], params_part2[3], params_part2[
4], params_part2[5], params_part2[6], params_part2[7]
output_part2 = classical_model.nonlinear_friction_model(
input[:, part2_index], c0, v_brk, F_brk, F_C, c1, c2, c3, c4)
else:
print("Either linear or nonlinear should be given in args")
reference = normer.denormalize_Y(normed_data_Y)
compensate_part1 = normer.denormalize_Y(output_part1)
compensate_part2 = normer.denormalize_Y(output_part2)
#Denormalize Safety restrictions:
compensate_part1 = np.clip(compensate_part1, -args.max_force,
args.max_force)
compensate_part2 = np.clip(compensate_part2, -args.max_force,
args.max_force)
#Compose together:
#TODO: solve the switch point.
compensate_full_series = np.zeros(len(raw_plan))
compensate_full_series[part1_index] = compensate_part1.reshape(-1)
compensate_full_series[part2_index] = compensate_part2.reshape(-1)
reference_full_series = raw_plan['need_to_compensate'].values
return compensate_full_series, reference_full_series
def get_compensate_force(raw_plan, part1_index, part2_index):
#Take out what we need:
raw_data_X = np.empty(shape=(0, len(raw_plan)))
for i in [0, 1, 2, 3, 4, 5]:
raw_data_X = np.vstack((raw_data_X, [
raw_plan['axc_speed_%s' % i], raw_plan['axc_pos_%s' % i],
raw_plan['axc_torque_ffw_gravity_%s' % i],
raw_plan['axc_torque_ffw_%s' % i]
]))
raw_data_X = np.vstack((raw_data_X, raw_plan['Temp']))
raw_data_Y = raw_plan['need_to_compensate'].values
#Normalize data:
normer = data_stuff.normalizer(raw_data_X)
normed_data_X, normed_data_Y = normer.normalize_XY(raw_data_X, raw_data_Y)
#Get model:
model_part1 = get_part1_model()
model_part2 = get_part2_model()
#Forward to get output:
inputs = torch.FloatTensor(normed_data_X.T)
output_part1 = model_part1.cpu()(inputs[part1_index]).detach().numpy()
output_part2 = model_part2.cpu()(inputs[part2_index]).detach().numpy()
reference = normer.denormalize_Y(normed_data_Y)
compensate_part1 = normer.denormalize_Y(output_part1)
compensate_part2 = normer.denormalize_Y(output_part2)
#Save for Production:
to_C(model_part1, model_part2, inputs)
#Denormalize Safety restrictions:
compensate_part1 = np.clip(compensate_part1, -args.max_force,
args.max_force)
compensate_part2 = np.clip(compensate_part2, -args.max_force,
args.max_force)
#Compose together:
#TODO: solve the switch point.
compensate_full_series = np.zeros(len(raw_plan))
compensate_full_series[part1_index] = compensate_part1.reshape(-1)
compensate_full_series[part2_index] = compensate_part2.reshape(-1)
reference_full_series = raw_plan['need_to_compensate'].values
return compensate_full_series, reference_full_series
def get_data_one(args, raw_plan, mode):
#Take out what we need:
#Make inputs:
raw_data_X = np.empty(shape=(0, len(raw_plan)))
input_columns_names = []
#data are index from 0, thus
local_axis_num = args.axis_num - 1
input_columns_names += ['axc_pos_%s' % local_axis_num]
input_columns_names += ['axc_speed_%s' % local_axis_num]
input_columns_names += ['axc_torque_ffw_gravity_%s' % local_axis_num]
input_columns_names += ['axc_torque_ffw_%s' % local_axis_num]
input_columns_names += ['Temp']
raw_data_X = raw_plan[input_columns_names].values.T
raw_data_Y = raw_plan['need_to_compensate'].values
#Normalize data:
normer = data_stuff.normalizer(raw_data_X, raw_data_Y, args)
normer.get_statistics(raw_data_X.shape[1])
raw_secure_range = normer.get_raw_secure()
judge_features_secure(args, raw_data_X, raw_secure_range,
input_columns_names)
normed_data_X, normed_data_Y = normer.normalize_XY(raw_data_X, raw_data_Y)
return normed_data_X, normed_data_Y, normer
def __init__(self, model_name, time_num=None):
self.model = NN_model.NeuralNet(input_size=25, hidden_size=25, hidden_depth=3, output_size=1, device=torch.device(device_type))
self.model.load_state_dict(torch.load(model_name).state_dict())
#self.model = torch.load(model_name, map_location=torch.device(device_type))
self.normer = data_stuff.normalizer(np.zeros((input_dim, buffer_length)))
print("Model Intialized", model_name)
def main():
parser = argparse.ArgumentParser(description='Friction.')
parser.add_argument('--learning_rate', '-LR', type=float, default=5e-2)
parser.add_argument('--test_ratio', '-TR', type=float, default=0.2)
parser.add_argument('--max_epoch', '-E', type=int, default=12)
parser.add_argument('--hidden_width_scaler', type=int, default=5)
parser.add_argument('--hidden_depth', type=int, default=3)
parser.add_argument('--axis_num', type=int, default=4)
parser.add_argument('--Cuda_number', type=int, default=0)
parser.add_argument('--num_of_batch', type=int, default=100)
parser.add_argument('--log_interval', type=int, default=100)
parser.add_argument('--VISUALIZATION',
"-V",
action='store_true',
default=False)
parser.add_argument('--NO_CUDA', action='store_true', default=False)
parser.add_argument('--Quick_data',
"-Q",
action='store_true',
default=False)
parser.add_argument('--mode',
type=str,
choices=["acc_uniform", "low_high"],
required=True)
parser.add_argument('--further_mode',
type=str,
choices=["acc", "uniform", "low", "high", "all"],
required=True)
parser.add_argument('--finetune', "-F", action='store_true', default=False)
args = parser.parse_args()
if not args.finetune:
args.pool_name = "data-j%s" % args.axis_num
else:
print(
"Running as finetune and restart, ignore validate loss which is trival"
)
args.pool_name = "finetune_path/"
args.learning_rate *= 0.1
args.test_ratio = 0.05
args.restart_model_path = "../models/NN_weights_best_all_%s" % args.axis_num
args.rated_torque = [5.7, 5.7, 1.02, 0.318, 0.318,
0.143][args.axis_num - 1]
print("Start...%s" % args)
if not args.NO_CUDA:
device = torch.device("cuda", args.Cuda_number)
print("Using GPU")
else:
device = torch.device("cpu")
print("Using CPU")
#-------------------------------------Do NN--------------------------------:
#Get data:
mode = ['train', args.mode]
raw_data, part1_index, part2_index = data_stuff.get_data(args, mode)
if args.further_mode == "acc" or args.further_mode == "low":
this_part = part1_index
elif args.further_mode == "uniform" or args.further_mode == "high":
this_part = part2_index
else: # args.further_mode=="all"
this_part = part1_index + part2_index
#Take variables we concerned:
#Make inputs:
print("PART start...%s" % args.further_mode)
raw_data_part = raw_data.iloc[this_part]
data_X = np.empty(shape=(0, len(raw_data_part)))
input_columns_names = []
#data is index from 0, thus:
local_axis_num = args.axis_num - 1
input_columns_names += ['axc_pos_%s' % local_axis_num]
input_columns_names += ['axc_speed_%s' % local_axis_num]
input_columns_names += ['axc_torque_ffw_gravity_%s' % local_axis_num]
input_columns_names += ['axc_torque_ffw_%s' % local_axis_num]
input_columns_names += ['Temp']
output_columns_names = ['need_to_compensate']
data_X = raw_data_part[input_columns_names].values.T
data_Y = raw_data_part[output_columns_names].values
print("Shape of all input: %s, shape of all output: %s" %
(data_X.shape, data_Y.shape))
#import my_analyzer
#my_analyzer.show_me_input_data(raw_data_part[input_columns_names])
#Normalize data:
normer = data_stuff.normalizer(data_X, data_Y, args)
if not args.finetune:
normer.generate_statistics()
normer.get_statistics(data_X.shape[1])
normer.generate_raw_secure()
X_normed, Y_normed = normer.normalize_XY(data_X, data_Y)
#MUST CHECK INPUT DISTRIBUTION!!!!!!
print("Checking distribution of all data...")
plot_utils.check_distribution(X_normed, input_columns_names, args)
plot_utils.check_distribution(Y_normed.T, output_columns_names, args)
#mannual split dataset: #Don't push dataset on cuda now, do so later after form dataset_loader
X_train, Y_train, X_val, Y_val, raw_data_train, raw_data_val = data_stuff.split_dataset(
args, X_normed, Y_normed, raw_data_part)
nn_X_train = torch.autograd.Variable(torch.FloatTensor(X_train.T))
nn_Y_train = torch.autograd.Variable(torch.FloatTensor(Y_train)).reshape(
-1, 1)
nn_X_val = torch.autograd.Variable(torch.FloatTensor(X_val.T))
nn_Y_val = torch.autograd.Variable(torch.FloatTensor(Y_val)).reshape(-1, 1)
#Just for showup high/low region
_ = evaluate.evaluate_error_rate(args,
Y_val.reshape(-1) * 0,
Y_val,
normer,
raw_data_val,
showup=args.VISUALIZATION)
#Form pytorch dataset:
train_dataset = Data.TensorDataset(nn_X_train, nn_Y_train)
validate_dataset = Data.TensorDataset(nn_X_val, nn_Y_val)
_batch_size = int(len(train_dataset) / args.num_of_batch)
train_loader = Data.DataLoader(dataset=train_dataset,
batch_size=_batch_size,
shuffle=True,
drop_last=False,
num_workers=4,
pin_memory=True)
validate_loader = Data.DataLoader(dataset=validate_dataset,
batch_size=_batch_size,
shuffle=True,
drop_last=False,
num_workers=4,
pin_memory=True)
#Model:
input_size = nn_X_train.shape[1]
hidden_size = nn_X_train.shape[1] * args.hidden_width_scaler
hidden_depth = args.hidden_depth
output_size = nn_Y_train.shape[1]
model = NN_model.NeuralNetSimple(input_size, hidden_size, hidden_depth,
output_size, device)
if args.finetune:
print("Loading resume model:", args.restart_model_path)
model.load_state_dict(torch.load(args.restart_model_path).state_dict())
#embed()
optimizer = optim.SGD(model.parameters(), lr=args.learning_rate)
if not args.finetune:
scheduler = optim.lr_scheduler.ReduceLROnPlateau(
optimizer,
'min',
patience=max(int(args.max_epoch / 10), 3),
factor=0.7)
else:
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,
'min',
patience=1e9,
factor=0.7)
print(model)
#embed()
#Train and Validate:
print("Now training...")
plt.ion()
train_loss_history = []
validate_loss_history = []
train_error_history = []
validate_error_history = []
history_error_ratio_val = []
overall_error_history = []
#This is for save gif, always on:
if args.VISUALIZATION:
plt.figure(figsize=(14, 8))
for epoch in range(int(args.max_epoch + 1)):
print("Epoch: %s" % epoch, "TEST AND SAVE FIRST")
#Test first:
#Push ALL data together through the network -- wtf just doesn't make sense GPU will explode, all on cpu now.
predicted_train = np.array(model.cpu()(
nn_X_train.cpu()).detach().cpu()).reshape(-1)
predicted_val = np.array(model.cpu()(
nn_X_val.cpu()).detach().cpu()).reshape(-1)
_, _, error_ratio_train = evaluate.evaluate_error_rate(args,
predicted_train,
nn_Y_train,
normer,
raw_data_train,
showup=False)
_, _, error_ratio_val = evaluate.evaluate_error_rate(args,
predicted_val,
nn_Y_val,
normer,
raw_data_val,
showup=False)
train_error_history.append(error_ratio_train)
validate_error_history.append(error_ratio_val)
overall_error_history.append(
(error_ratio_train + error_ratio_val).mean())
scheduler.step(error_ratio_val)
print("Using lr:", optimizer.state_dict()['param_groups'][0]['lr'])
model.eval()
print("Train set error ratio:", error_ratio_train)
print("Validate set error ratio:", error_ratio_val)
if not args.finetune:
if epoch >= 1:
if overall_error_history[-1] < np.array(
overall_error_history[:-1]).min():
torch.save(
model.eval(), "../models/NN_weights_best_%s_%s" %
(args.further_mode, args.axis_num))
print("***MODEL SAVED***")
else:
if epoch > 0:
if train_error_history[-1] < np.array(
train_error_history[:-1]).min():
#validate loss is not refered to as its very few.
torch.save(
model.eval(),
"../models/NN_weights_best_%s_%s_finetune" %
(args.further_mode, args.axis_num))
print("***MODEL SAVED***")
pd.DataFrame(np.vstack(
(predicted_val, np.array(nn_Y_val.detach().cpu()).reshape(-1))).T,
columns=['predicted', 'target']).to_csv(
"../output/best_val_predicted_vs_target.csv",
index=None)
#Always save figure:
#plot_utils.visual(nn_Y_val, predicted_val, 'NN', args, title=error_ratio_val, epoch=epoch)
history_error_ratio_val.append(error_ratio_val)
#Train/Val then:
train_loss, train_outputs, train_targets = train(
args, model, device, train_loader, optimizer, epoch)
validate_loss, validate_outputs, validate_targets = validate(
args, model, device, validate_loader)
#Infos:
train_loss_history.append(train_loss)
validate_loss_history.append(validate_loss)
print("Train set Average loss: {:.8f}".format(train_loss))
print('Validate set Average loss: {:.8f}'.format(validate_loss))
if args.VISUALIZATION:
plt.close()
plt.ioff()
plt.clf()
plt.plot(train_loss_history, label='train loss')
plt.plot(validate_loss_history, label='val loss')
plt.title("Train/Val loss history")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
#plt.draw()
#plt.pause(2)
plt.show()
plt.close()
names_note = "NN weights"
print("Names note:", names_note)
print("NN:", "NONE")
if not args.finetune:
print("Error rate:",
np.array(history_error_ratio_val).min(), "at index",
np.array(history_error_ratio_val).argmin())
else:
pass
plt.figure(figsize=(14, 8))
for _idx_, this_part in enumerate([part1_index, part2_index]):
print("PART start...")
raw_data_part = raw_data.iloc[this_part]
data_Y = raw_data_part['need_to_compensate'].values
#Take variables we concerned:
data_X = np.array([
raw_data_part['axc_speed_%s' % args.axis_num],
raw_data_part['axc_torque_ffw_gravity_%s' % args.axis_num],
raw_data_part['Temp'], raw_data_part['axc_pos_%s' % args.axis_num]
])
data_X = np.insert(data_X, 0, 1, axis=0)
#Normalize data:
normer = data_stuff.normalizer(data_X)
X_normed, Y_normed = normer.normalize_XY(data_X, data_Y)
#mannual split dataset:
X_train, Y_train, X_val, Y_val, raw_data_part_train, raw_data_part_val = data_stuff.split_dataset(
args, X_normed, Y_normed, raw_data_part)
#Train linear model:
print("Training on linear...")
linear_names_note = ['c0', 'c1', 'c2', 'c3', 'c4']
linear_weights, linear_cov = curve_fit(
classical_model.linear_friction_model,
X_train,
Y_train,
maxfev=5000000)
#Train nonlinear model:
print("Training on nonlinear...")
axis_num = 4
axis_num = axis_num - 1
data_path = "../data/planning.csv"
#Get data:
raw_data = data_stuff.get_planning_data(data_path, axis_num)
raw_data_X = np.array([
raw_data['axc_speed_%s' % axis_num],
raw_data['axc_torque_ffw_gravity_%s' % axis_num], raw_data['Temp'],
raw_data['axc_pos_%s' % axis_num]
]) #TODO: this is axis 4
raw_data_X = np.insert(raw_data_X, 0, 1, axis=0)
raw_data_Y = raw_data['need_to_compensate'].values
#Normalize data:
normer = data_stuff.normalizer(raw_data_X)
normed_data_X, normed_data_Y = normer.normalize_XY(raw_data_X, raw_data_Y)
#Get model:
params = get_model_params()
#Forward to get output:
c0, c1, c2, c3, c4 = params[0], params[1], params[2], params[3], params[4]
input = normed_data_X
output = classical_model.linear_friction_model(input, c0, c1, c2, c3, c4)
#Denormalize Safety restrictions:
compensate = normer.denormalize_Y(output)
compensate = np.clip(compensate, -max_force, max_force)
print("Done")