def scaling_data(self, train_features, train_targets, test_features, s_tar,
m_tar, s_feat, m_feat):
"""Scaling the data if requested.
Parameters
----------
train_feature : array
Independent data used to train model.
train_targets : array
Dependent data used to train model.
test_features : array
Independent data used to test the model.
s_tar : array
Standard devation or (max-min), for the dependent train_targets.
m_tar : array
Mean for the dependent train_targets.
s_feat : array
Standard devation or (max-min), for the independent train_features.
m_feat : array
Mean for the independent train_features.
"""
train_features = train_features[:, :self.features]
test_features = test_features[:, :self.features]
if self.scale:
if self.normalization:
# Normalize
if s_tar is None or m_tar is None:
data = target_normalize(target=train_targets)
s_tar, m_tar, train_targets = (data['dif'], data['mean'],
data['target'])
norm = normalize(train_matrix=train_features,
test_matrix=test_features,
dif=s_feat,
mean=m_feat)
train_features, test_features, s_feat, m_feat = (norm['train'],
norm['test'],
norm['dif'],
norm['mean'])
else:
# Standardization
if s_tar is None or m_tar is None:
data = target_standardize(target=train_targets)
s_tar, m_tar, train_targets = (data['std'], data['mean'],
data['target'])
std = standardize(train_matrix=train_features,
test_matrix=test_features,
std=s_feat,
mean=m_feat)
train_features, test_features, s_feat, m_feat = (std['train'],
std['test'],
std['std'],
std['mean'])
return (s_tar, m_tar, s_feat, m_feat, train_targets, train_features,
test_features)
def train(self):
"""Scale the training features and targets.
Returns
-------
feature_data : array
The scaled features for the training data.
target_data : array
The scaled targets for the training data.
"""
self.feature_data = standardize(train_matrix=self.train_features)
self.target_data = target_standardize(target=self.train_targets)
return self.feature_data['train'], self.target_data['target']
def test_scale(self):
"""Test data scaling functions."""
train_features, train_targets, test_features, _ = self.get_data()
sfp = standardize(train_matrix=train_features,
test_matrix=test_features)
sfpg = standardize(train_matrix=train_features,
test_matrix=test_features,
local=False)
self.assertFalse(np.allclose(sfp['train'], sfpg['train']))
nfp = normalize(train_matrix=train_features, test_matrix=test_features)
nfpg = normalize(train_matrix=train_features,
test_matrix=test_features,
local=False)
self.assertFalse(np.allclose(nfp['train'], nfpg['train']))
mmfp = min_max(train_matrix=train_features, test_matrix=test_features)
mmfpg = min_max(train_matrix=train_features,
test_matrix=test_features,
local=False)
self.assertFalse(np.allclose(mmfp['train'], mmfpg['train']))
ulfp = unit_length(train_matrix=train_features,
test_matrix=test_features)
ulfpg = unit_length(train_matrix=train_features,
test_matrix=test_features,
local=False)
self.assertTrue(np.allclose(ulfp['train'], ulfpg['train']))
ts = target_standardize(train_targets)
self.assertFalse(np.allclose(ts['target'], train_targets))
ts = target_normalize(train_targets)
self.assertFalse(np.allclose(ts['target'], train_targets))
ts = target_center(train_targets)
self.assertFalse(np.allclose(ts['target'], train_targets))
# Generate test datapoints x.
test_points = 513
test = np.vstack(
np.linspace(np.min(train) - 0.1,
np.max(train) + 0.1, test_points))
# Store standard deviations of the training data and targets.
stdx = np.std(train)
stdy = np.std(target)
tstd = 2.
# Standardize the training and test data on the same scale.
std = standardize(train_matrix=train, test_matrix=test)
# Standardize the training targets.
train_targets = target_standardize(target)
# Note that predictions will now be made on the standardized scale.
# Store the known underlying function for plotting.
linex = np.linspace(np.min(test), np.max(test), test_points)
liney = afunc(linex)
# Plotting.
fig = plt.figure(figsize=(15, 8))
if haz_gpy or haz_gpflow:
grid = 230
last = 6
else:
grid = 220
last = 4
ax224 = fig.add_subplot(grid + last)
plt.title('Uncertainty Profiles')
def scale_test(train_matrix, train_targets, test_matrix):
"""Test data scaling functions."""
sfp = standardize(train_matrix=train_matrix, test_matrix=test_matrix)
ts = target_standardize(train_targets)
return sfp['train'], ts['target'], sfp['test']