The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.
Example 1
def parameterChoosing(self):
# Set the parameters by cross-validation
tuned_parameters = [{'penalty': ['l1'],
'C': np.logspace(-5,5)},
{'penalty': ['l2'],
'C': np.logspace(-5,5)}]
clf = GridSearchCV(linear_model.LogisticRegression(tol=1e-6), tuned_parameters, cv=5, scoring='precision_weighted')
clf.fit(self.X_train, self.y_train.ravel())
print "Best parameters set found on development set:\n"
print clf.best_params_
print "Grid scores on development set:\n"
for params, mean_score, scores in clf.grid_scores_:
print "%0.3f (+/-%0.03f) for %r\n" % (mean_score, scores.std() * 2, params)
print "Detailed classification report:\n"
y_true, y_pred = self.y_test, clf.predict(self.X_test)
print classification_report(y_true, y_pred) Example 2
def calc_IndCurrent_FD_spectrum(self):
"""Gives FD induced current spectrum"""
#INITIALIZE ATTRIBUTES
Bpx = self.Bpx
Bpz = self.Bpz
a2 = self.a2
azm = np.pi*self.azm/180.
R = self.R
L = self.L
w = 2*np.pi*np.logspace(0,8,101)
Ax = np.pi*a2**2*np.sin(azm)
Az = np.pi*a2**2*np.cos(azm)
Phi = (Ax*Bpx + Az*Bpz)
EMF = -1j*w*Phi
Is = EMF/(R + 1j*w*L)
return EMF,Is Example 3
def WaveVelandSkindWidget(epsr, sigma):
frequency = np.logspace(1, 9, 61)
vel, skind = WaveVelSkind(frequency, epsr, 10**sigma)
figure, ax = plt.subplots(1, 2, figsize = (10, 4))
ax[0].loglog(frequency, vel, 'b', lw=3)
ax[1].loglog(frequency, skind, 'r', lw=3)
ax[0].set_ylim(1e6, 1e9)
ax[1].set_ylim(1e-1, 1e7)
ax[0].set_xlabel('Frequency (Hz)')
ax[0].set_ylabel('Velocity (m/s)')
ax[1].set_xlabel('Frequency (Hz)')
ax[1].set_ylabel('Skin Depth (m)')
ax[0].grid(True)
ax[1].grid(True)
plt.show()
return Example 4
def process(self, **kwargs):
"""Process module."""
self._rest_times = kwargs['rest_times']
self._rest_t_explosion = kwargs[self.key('resttexplosion')]
outputs = OrderedDict()
max_times = max(self._rest_times)
if max_times > self._rest_t_explosion:
outputs['dense_times'] = np.unique(
np.concatenate(([0.0], [
x + self._rest_t_explosion
for x in np.logspace(
self.L_T_MIN,
np.log10(max_times - self._rest_t_explosion),
num=self._n_times)
], self._rest_times)))
else:
outputs['dense_times'] = np.array(self._rest_times)
outputs['dense_indices'] = np.searchsorted(
outputs['dense_times'], self._rest_times)
return outputs Example 5
def main(table, schema):
logger = get_root_logger()
_ = get_header(logger, 'Building a model to predict Trump tweets')
loc = get_path(__file__) + '/{0}'
params = {
'features__text_processing__vect__ngram_range': [(1, 1), (1, 2), (1, 3)],
'clf__n_estimators': [int(x) for x in logspace(1, 3, num=10)]
}
model = RandomForestModel(table, schema, **params)
model.train()
model.evaluate()
model.save(loc.format('saved_models')) Example 6
def _get_knot_spacing(self):
"""Returns a list of knot locations based on the spline parameters
If the option `spacing` is 'lin', uses linear spacing
'log', uses log spacing
Places 'spline_N' knots between 'spline_min' and 'spline_max'
"""
space_key = self.get_option('spacing').lower()[:3]
if space_key == 'log':
vol = np.logspace(np.log10(self.get_option('spline_min')),
np.log10(self.get_option('spline_max')),
self.get_option('spline_N'))
elif space_key == 'lin':
vol = np.linspace(self.get_option('spline_min'),
self.get_option('spline_max'),
self.get_option('spline_N'))
else:
raise KeyError("{:} only `lin`ear and `log` spacing are"
"accepted".format(self.get_inform(1)))
# end
return vol Example 7
def plot():
'''
'''
# Register the functions
builtins.__dict__.update(globals())
# Loop over various dataset sizes
Narr = np.logspace(0, 5, 5)
tpp = np.zeros_like(Narr)
tbm = np.zeros_like(Narr)
tps = np.zeros_like(Narr)
for i, N in enumerate(Narr):
tpp[i] = timeit.timeit('run_pp(%d)' % N, number = 10) / 10.
if batman is not None:
tbm[i] = timeit.timeit('run_bm(%d)' % N, number = 10) / 10.
if ps is not None:
tps[i] = timeit.timeit('run_ps(%d)' % N, number = 10) / 10.
pl.plot(Narr, tpp, '-o', label = 'planetplanet')
if batman is not None:
pl.plot(Narr, tbm, '-o', label = 'batman')
if ps is not None:
pl.plot(Narr, tps, '-o', label = 'pysyzygy')
pl.legend()
pl.yscale('log')
pl.xscale('log')
pl.ylabel('Time [seconds]', fontweight = 'bold')
pl.xlabel('Number of datapoints', fontweight = 'bold') Example 8
def fit_koff(nmax=523, NN=4e8, **params):
tbind = params.pop("tbind")
params["kd"] = 1e9/tbind
dx = params.pop("dx")
rw = randomwalk.get_rw(NAME, params, setup=setup_rw, calc=True)
rw.domains[1].dx = dx
times = draw_empirically(rw, N=NN, nmax=nmax, success=False)
bins = np.logspace(np.log10(min(times)), np.log10(max(times)), 35)
#bins = np.logspace(-3., 2., 35)
hist, _ = np.histogram(times, bins=bins)
cfd = np.cumsum(hist)/float(np.sum(hist))
t = 0.5*(bins[:-1] + bins[1:])
tmean = times.mean()
toff = NLS(t, cfd, t0=tmean)
koff = 1./toff
return dict(t=t, cfd=cfd, toff=toff, tmean=tmean, koff=koff)
##### run rw in collect mode and draw bindings from empirical distributions Example 9
def exponential_hist(times, a, b, **params):
cutoff = 0.03 # cutoff frequency in ms
if len(times) == 0:
return
bins = np.logspace(a, b, 100)
hist = plt.hist(times, bins=bins, alpha=0.5, **params)
plt.xscale("log")
params.pop("label")
color = params.pop("color")
total = integrate_hist(hist, cutoff)
if sum(times > cutoff) == 0:
return
tmean = times[times > cutoff].mean()
T = np.logspace(a-3, b, 1000)
fT = np.exp(-T/tmean)*T/tmean
fT *= total/integrate_values(T, fT, cutoff)
plt.plot(T, fT, label="exp. fit, mean = %.2f ms" % (tmean,),
color="dark" + color, **params)
plt.xlim(10**a, 10**b) Example 10
def _update_data_x(self):
if self.is_zero_span():
self._data_x = np.zeros(self.points)
# data_x will be measured during first scan...
return
if self.logscale:
raw_values = np.logspace(
np.log10(self.start_freq),
np.log10(self.stop_freq),
self.points,
endpoint=True)
else:
raw_values = np.linspace(self.start_freq,
self.stop_freq,
self.points,
endpoint=True)
values = np.zeros(len(raw_values))
for index, val in enumerate(raw_values):
values[index] = self.iq.__class__.frequency. \
validate_and_normalize(self, val) # retrieve the real freqs...
self._data_x = values Example 11
def MieQ_withWavelengthRange(m, diameter, wavelengthRange=(100,1600), nw=1000, logW=False):
# http://pymiescatt.readthedocs.io/en/latest/forward.html#MieQ_withWavelengthRange
if type(m) == complex and len(wavelengthRange)==2:
if logW:
wavelengths = np.logspace(np.log10(wavelengthRange[0]),np.log10(wavelengthRange[1]),nw)
else:
wavelengths = np.linspace(wavelengthRange[0],wavelengthRange[1],nw)
_qD = [AutoMieQ(m,wavelength,diameter) for wavelength in wavelengths]
elif type(m) in [np.ndarray,list,tuple] and len(wavelengthRange)==len(m):
wavelengths=wavelengthRange
_qD = [MieQ(emm,wavelength,diameter) for emm,wavelength in zip(m,wavelengths)]
else:
warnings.warn("Error: the size of the input data is minmatched. Please examine your inputs and try again.")
return
qext = np.array([q[0] for q in _qD])
qsca = np.array([q[1] for q in _qD])
qabs = np.array([q[2] for q in _qD])
g = np.array([q[3] for q in _qD])
qpr = np.array([q[4] for q in _qD])
qback = np.array([q[5] for q in _qD])
qratio = np.array([q[6] for q in _qD])
return wavelengths, qext, qsca, qabs, g, qpr, qback, qratio Example 12
def MieQ_withSizeParameterRange(m, xRange=(1,10), nx=1000, logX=False):
# http://pymiescatt.readthedocs.io/en/latest/forward.html#MieQ_withSizeParameterRange
if logX:
xValues = list(np.logspace(np.log10(xRange[0]),np.log10(xRange[1]),nx))
else:
xValues = list(np.linspace(xRange[0],xRange[1], nx))
dValues = [1000*x/np.pi for x in xValues]
_qD = [AutoMieQ(m,1000,d) for d in dValues]
qext = np.array([q[0] for q in _qD])
qsca = np.array([q[1] for q in _qD])
qabs = np.array([q[2] for q in _qD])
g = np.array([q[3] for q in _qD])
qpr = np.array([q[4] for q in _qD])
qback = np.array([q[5] for q in _qD])
qratio = np.array([q[6] for q in _qD])
return xValues, qext, qsca, qabs, g, qpr, qback, qratio Example 13
def MieQ_withWavelengthRange(m, diameter, wavelengthRange=(100,1600), nw=1000, logW=False):
# http://pymiescatt.readthedocs.io/en/latest/forward.html#MieQ_withWavelengthRange
if type(m) == complex and len(wavelengthRange)==2:
if logW:
wavelengths = np.logspace(np.log10(wavelengthRange[0]),np.log10(wavelengthRange[1]),nw)
else:
wavelengths = np.linspace(wavelengthRange[0],wavelengthRange[1],nw)
_qD = [AutoMieQ(m,wavelength,diameter) for wavelength in wavelengths]
elif type(m) in [np.ndarray,list,tuple] and len(wavelengthRange)==len(m):
wavelengths=wavelengthRange
_qD = [MieQ(emm,wavelength,diameter) for emm,wavelength in zip(m,wavelengths)]
else:
warnings.warn("Error: the size of the input data is minmatched. Please examine your inputs and try again.")
return
qext = np.array([q[0] for q in _qD])
qsca = np.array([q[1] for q in _qD])
qabs = np.array([q[2] for q in _qD])
g = np.array([q[3] for q in _qD])
qpr = np.array([q[4] for q in _qD])
qback = np.array([q[5] for q in _qD])
qratio = np.array([q[6] for q in _qD])
return wavelengths, qext, qsca, qabs, g, qpr, qback, qratio Example 14
def MieQ_withSizeParameterRange(m, xRange=(1,10), nx=1000, logX=False):
# http://pymiescatt.readthedocs.io/en/latest/forward.html#MieQ_withSizeParameterRange
if logX:
xValues = list(np.logspace(np.log10(xRange[0]),np.log10(xRange[1]),nx))
else:
xValues = list(np.linspace(xRange[0],xRange[1], nx))
dValues = [1000*x/np.pi for x in xValues]
_qD = [AutoMieQ(m,1000,d) for d in dValues]
qext = np.array([q[0] for q in _qD])
qsca = np.array([q[1] for q in _qD])
qabs = np.array([q[2] for q in _qD])
g = np.array([q[3] for q in _qD])
qpr = np.array([q[4] for q in _qD])
qback = np.array([q[5] for q in _qD])
qratio = np.array([q[6] for q in _qD])
return xValues, qext, qsca, qabs, g, qpr, qback, qratio Example 15
def grid_search_gamma(rbf_svm, X, y):
## grid search - gamma only
# use a full grid over all parameters
param_grid = {'gamma': np.logspace(-15, 4, num = 5000, base = 2.0)}
grid_search = GridSearchCV(rbf_svm, param_grid = param_grid, scoring = 'roc_auc',
cv = 10, pre_dispatch = '2*n_jobs', n_jobs = -1)
# re-fit on the whole training data
grid_search.fit(X, y)
grid_search_scores = [score[1] for score in grid_search.grid_scores_]
print('Best parameters : {}'.format(grid_search.best_params_))
print('Best score : {}'.format(grid_search.best_score_))
# set canvas
fig, ax = plt.subplots(1, 1)
# ax.scatter(X[:, 0], X[:, 1], c = y)
ax.plot(param_grid['gamma'], grid_search_scores)
ax.set_title('AUC = f(gamma, C = 1.0)', fontsize = 'large')
ax.set_xlabel('gamma', fontsize = 'medium')
ax.set_ylabel('AUC', fontsize = 'medium')
return fig Example 16
def test_cv():
"""Simple CV check."""
# XXX: don't use scikit-learn for tests.
X, y = make_regression()
cv = KFold(X.shape[0], 5)
glm_normal = GLM(distr='gaussian', alpha=0.01, reg_lambda=0.1)
# check that it returns 5 scores
scores = cross_val_score(glm_normal, X, y, cv=cv)
assert_equal(len(scores), 5)
param_grid = [{'alpha': np.linspace(0.01, 0.99, 2)},
{'reg_lambda': np.logspace(np.log(0.5), np.log(0.01),
10, base=np.exp(1))}]
glmcv = GridSearchCV(glm_normal, param_grid, cv=cv)
glmcv.fit(X, y) Example 17
def test_l1l2path():
X_file = 'data_c/X_200_100.csv'
Y_file = 'data_c/Y_200_100.csv'
X = np.genfromtxt(X_file)
Y = np.genfromtxt(Y_file)
mu = 1e-3
tau_range = np.logspace(-2,0,3)
k_max = 10000
tolerance = 1e-4
pc = pplus.PPlusConnection(debug=False, workers_servers = ('127.0.0.1',))
pc.submit(l1l2path_job,
args=(X, Y, mu, tau_range, k_max, tolerance),
modules=('numpy as np', 'ctypes'))
result_keys = pc.collect()
print result_keys
print("Done") Example 18
def nextfastpower(n):
"""Return the next integral power of small factors greater than the given
number. Specifically, return m such that
m >= n
m == 2**x * 3**y * 5**z
where x, y, and z are integers.
This is useful for ensuring fast FFT sizes.
From https://gist.github.com/bhawkins/4479607 (Brian Hawkins)
"""
if n < 7:
return max (n, 1)
# x, y, and z are all bounded from above by the formula of nextpower.
# Compute all possible combinations for powers of 3 and 5.
# (Not too many for reasonable FFT sizes.)
def power_series (x, base):
nmax = ceil (log (x) / log (base))
return np.logspace (0.0, nmax, num=nmax+1, base=base)
n35 = np.outer (power_series (n, 3.0), power_series (n, 5.0))
n35 = n35[n35<=n]
# Lump the powers of 3 and 5 together and solve for the powers of 2.
n2 = nextpower (n / n35)
return int (min (n2 * n35)) Example 19
def _generate_segments(self, n_segments, n_superpositions=5):
# Assume that the actual surface is a superposition of sinusoid
# functions from which sample n_segments points and connect those
# linearly
# Generate sinusoids of the form -5 * sin(a * x + b)
a = np.logspace(0, 0.5, n_superpositions)
b = (0.25 * self.random_state.rand(n_superpositions) - 0.125) * np.pi
# Generate x and y components of segments
x = np.hstack((np.sort(self.random_state.rand(n_segments) * 8.0)))
y = (-5 * np.sin(a * x[:, None] + b)).mean(axis=1)
# Start at (0, 0)
x[0] = y[0] = 0
# Planar segment at the end which is long enough to avoid shooting
# over the border
x[-1] = 100.0
y[-1] = y[-2]
return np.vstack((x, y)).T Example 20
def parameterChoosing(self):
# Set the parameters by cross-validation
tuned_parameters = [{'alpha': np.logspace(-5,5)
}
]
reg = GridSearchCV(linear_model.Ridge(alpha = 0.5), tuned_parameters, cv=5, scoring='mean_squared_error')
reg.fit(self.X_train, self.y_train)
print "Best parameters set found on development set:\n"
print reg.best_params_
print "Grid scores on development set:\n"
for params, mean_score, scores in reg.grid_scores_:
print "%0.3f (+/-%0.03f) for %r\n" % (mean_score, scores.std() * 2, params)
print reg.scorer_
print "MSE for test data set:"
y_true, y_pred = self.y_test, reg.predict(self.X_test)
print mean_squared_error(y_pred, y_true) Example 21
def parameterChoosing(self):
# Set the parameters by cross-validation
tuned_parameters = [{'kernel': ['rbf'],
'gamma': np.logspace(-4, 3, 30),
'C': [1e-3, 1e-2, 1e-1, 1, 10, 100, 1000]},
{'kernel': ['poly'],
'degree': [1, 2, 3, 4],
'C': [1e-3, 1e-2, 1e-1, 1, 10, 100, 1000],
'coef0': np.logspace(-4, 3, 30)},
{'kernel': ['linear'],
'C': [1e-3, 1e-2, 1e-1, 1, 10, 100, 1000]}]
clf = GridSearchCV(svm.SVC(C=1), tuned_parameters, cv=5, scoring='precision_weighted')
clf.fit(self.X_train, self.y_train.ravel())
print "Best parameters set found on development set:\n"
print clf.best_params_
print "Grid scores on development set:\n"
for params, mean_score, scores in clf.grid_scores_:
print "%0.3f (+/-%0.03f) for %r\n" % (mean_score, scores.std() * 2, params)
print "Detailed classification report:\n"
y_true, y_pred = self.y_test, clf.predict(self.X_test)
print classification_report(y_true, y_pred) Example 22
def b2t(tb, n=1e2, logger=None, **kwargs):
tb = np.array(tb)
if isinstance(tb, type(1.1)):
return a2t(b2a(tb))
if tb.shape == ():
return a2t(b2a(tb))
if len(tb) < n:
n = len(tb)
tbs = -1.*np.logspace(np.log10(-tb.min()),
np.log10(-tb.max()), n)
ages = []
for i, tbi in enumerate(tbs):
ages += a2t(b2a(tbi)),
if logger:
logger(i)
ages = np.array(ages)
return tbs, ages Example 23
def run(n_seeds, n_jobs, _run, _seed):
seed_list = check_random_state(_seed).randint(np.iinfo(np.uint32).max,
size=n_seeds)
exps = []
exps += [{'method': 'sgd',
'step_size': step_size}
for step_size in np.logspace(-3, 3, 7)]
exps += [{'method': 'gram',
'reduction': reduction}
for reduction in [1, 4, 6, 8, 12, 24]]
rundir = join(basedir, str(_run._id), 'run')
if not os.path.exists(rundir):
os.makedirs(rundir)
Parallel(n_jobs=n_jobs,
verbose=10)(delayed(single_run)(config_updates, rundir, i)
for i, config_updates in enumerate(exps)) Example 24
def run(n_seeds, n_jobs, _run, _seed):
seed_list = check_random_state(_seed).randint(np.iinfo(np.uint32).max,
size=n_seeds)
exps = []
exps += [{'method': 'sgd',
'step_size': step_size}
for step_size in np.logspace(-7, -7, 1)]
exps += [{'method': 'gram',
'reduction': reduction}
for reduction in [12]]
rundir = join(basedir, str(_run._id), 'run')
if not os.path.exists(rundir):
os.makedirs(rundir)
Parallel(n_jobs=n_jobs,
verbose=10)(delayed(single_run)(config_updates, rundir, i)
for i, config_updates in enumerate(exps)) Example 25
def create_matrix_sparse_from_conf(conf):
restypes = ['tdnn', 'lpfb']
# tdnn res weights = []
if 'restype' not in conf or conf['restype'] not in restypes:
return None
else:
if conf['restype'] == 'tdnn':
w_ = spa.dia_matrix(np.diag(np.ones((conf['N']-1,)), k = -1))
return w_
elif conf['restype'] == 'lpfb':
# w_ = spa.dia_matrix(np.diag(1 - (np.logspace(1e-3, 1e-1, conf['N']) - 1), k = 0))
w_ = spa.dia_matrix(np.diag(1 - np.exp(np.linspace(-6, -0.69, conf['N'])), k = 0))
return w_
return None
################################################################################
# Standalone class for learning rules
# - Recursive Least Squares (RLS, depends on rlspy.py): the vanilla online supervised
# reservoir training method
# - First-order reduced and controlled error or FORCE learning (Sussillo & Abbott, 2012)
# - FORCEmdn: Mixture density output layer using FORCE rule (Berthold, 2017)
# - Exploratory Hebbian learning (Legenstein & others, 2010) Example 26
def selectFixedOrLog(self):
"""
Check fixed or log-linear asymmetry parameter
"""
self.parameters['fixed_p'] = self.ui.radioButtonFixedP.isChecked()
if self.parameters['fixed_p']:
self.ui.radioButtonFixedP.setChecked(True)
self.ui.radioButtonLogLinearP.setChecked(False)
self.ui.frame_2.setEnabled(False)
self.ui.frame.setEnabled(True)
# self.p = lambda x: self.ui.spinBoxP.value()
self.parameters['asym_param'] = self.ui.spinBoxP.value()
else:
self.ui.radioButtonFixedP.setChecked(False)
self.ui.radioButtonLogLinearP.setChecked(True)
self.ui.frame_2.setEnabled(True)
self.ui.frame.setEnabled(False)
self.parameters['asym_param'] = \
lambda x: _np.logspace(_np.log10(self.parameters['asym_param_start']),
_np.log10(self.parameters['asym_param_end']),x)
self.changed.emit() Example 27
def getOpts(opts):
print("config opts...")
opts['validation'] = 0.1
opts['exemplarSize'] = 127
opts['instanceSize'] = 255-2*8
opts['lossRPos'] = 16
opts['lossRNeg'] = 0
opts['labelWeight'] = 'balanced'
opts['numPairs'] = 53200
opts['frameRange'] = 100
opts['trainNumEpochs'] = 50
opts['trainLr'] = np.logspace(-2, -5, opts['trainNumEpochs'])
opts['trainWeightDecay'] = 5e-04
opts['randomSeed'] = 1
opts['momentum'] = 0.9
opts['stddev'] = 0.01
opts['start'] = 0
opts['expName'] = '_20170511_s_tn_001'
opts['summaryFile'] = './data_20170511/'+opts['expName']
opts['ckptPath'] = './ckpt/'+opts['expName']
return opts Example 28
def getOpts(opts):
print("config opts...")
opts['validation'] = 0.1
opts['exemplarSize'] = 127
opts['instanceSize'] = 255-2*8
opts['lossRPos'] = 16
opts['lossRNeg'] = 0
opts['labelWeight'] = 'balanced'
opts['numPairs'] = 53200
opts['frameRange'] = 100
opts['trainNumEpochs'] = 50
opts['trainLr'] = np.logspace(-2, -5, opts['trainNumEpochs'])
opts['trainWeightDecay'] = 5e-04
opts['randomSeed'] = 1
opts['momentum'] = 0.9
opts['stddev'] = 0.01
opts['start'] = 0
opts['expName'] = '20170518_tn_o_001'
opts['summaryFile'] = './data_20170518/'+opts['expName']
opts['ckptPath'] = './ckpt/'+opts['expName']
return opts Example 29
def CAL_v(name, label_p, label_n, oracle, n_features, ftype, test_x, test_y):
online = OnlineBase(name, label_p, label_n, oracle, n_features, ftype, error=.5)
x, y = online.collect_pts(100, -1)
i = 0
q = online.get_n_query()
C_range = np.logspace(-2, 5, 10, base=10)
gamma_range = np.logspace(-5, 1, 10, base=10)
param_grid = dict(gamma=gamma_range, C=C_range)
while q < 3500:
i += 1
# h_ = ex.fit(x, y)
cv = StratifiedShuffleSplit(y, n_iter=5, test_size=0.2, random_state=42)
grid = GridSearchCV(svm.SVC(), param_grid=param_grid, cv=cv, verbose=0, n_jobs=-1)
grid.fit(x, y)
h_ = grid.best_estimator_
online_ = OnlineBase('', label_p, label_n, h_.predict, n_features, ftype, error=.1)
x_, _ = online_.collect_pts(10, 200)
if x_ is not None and len(x_) > 0:
x.extend(x_)
y.extend(oracle(x_))
q += online_.get_n_query()
pred_y = h_.predict(test_x)
print len(x), q, sm.accuracy_score(test_y, pred_y) Example 30
def grid_retrain_in_f(self, n_dim=500):
rbf_map = RBFSampler(n_dim, random_state=1)
fourier_approx_svm = pipeline.Pipeline([("mapper", rbf_map),
("svm", LinearSVC())])
# C_range = np.logspace(-5, 15, 21, base=2)
# gamma_range = np.logspace(-15, 3, 19, base=2)
# param_grid = dict(mapper__gamma=gamma_range, svm__C=C_range)
# cv = StratifiedShuffleSplit(Y, n_iter=5, test_size=0.2, random_state=42)
# grid = GridSearchCV(fourier_approx_svm, param_grid=param_grid, cv=cv)
# grid.fit(X, Y)
#
# rbf_svc2 = grid.best_estimator_
rbf_svc2 = fourier_approx_svm
rbf_svc2.fit(self.X_ex, self.y_ex)
self.set_clf2(rbf_svc2)
return self.benchmark() Example 31
def grid_search(self):
C_range = np.logspace(-5, 15, 21, base=2)
param_grid = dict(C=C_range)
cv = StratifiedShuffleSplit(self.y_ex, n_iter=5, test_size=0.2, random_state=42)
grid = GridSearchCV(SVC(kernel='poly', max_iter=10000), param_grid=param_grid, cv=cv, n_jobs=1, verbose=0)
logger.info('start grid search for Linear')
grid.fit(self.X_ex, self.y_ex)
logger.info('end grid search for Linear')
scores = [x[1] for x in grid.grid_scores_]
# final train
clf = grid.best_estimator_
pred_train = clf.predict(self.X_ex)
pred_val = clf.predict(self.val_x)
pred_test = clf.predict(self.test_x)
r = Result(self.name + ' (X)', 'Poly', len(self.X_ex),
sm.accuracy_score(self.y_ex, pred_train),
sm.accuracy_score(self.val_y, pred_val),
sm.accuracy_score(self.test_y, pred_test))
return r Example 32
def wage_data_linear():
X, y = wage()
gam = LinearGAM(n_splines=10)
gam.gridsearch(X, y, lam=np.logspace(-5,3,50))
XX = generate_X_grid(gam)
plt.figure()
fig, axs = plt.subplots(1,3)
titles = ['year', 'age', 'education']
for i, ax in enumerate(axs):
ax.plot(XX[:, i], gam.partial_dependence(XX, feature=i+1))
ax.plot(XX[:, i], *gam.partial_dependence(XX, feature=i+1, width=.95)[1],
c='r', ls='--')
if i == 0:
ax.set_ylim(-30,30);
ax.set_title(titles[i])
fig.tight_layout()
plt.savefig('imgs/pygam_wage_data_linear.png', dpi=300) Example 33
def plot_pdf_log2(x, nbins=10, **kwargs):
'''
Adds a log-log PDF plot to the current axes. The PDF is binned with
logarithmic binning of base 2.
Arguments
---------
x : array_like
The data to plot
nbins : integer
The number of bins to take
Additional keyword arguments are passed to `matplotlib.pyplot.loglog`.
'''
x = np.asarray(x)
exp_max = np.ceil(np.log2(x.max()))
bins = np.logspace(0, exp_max, exp_max + 1, base=2)
ax = plt.gca()
hist, _ = np.histogram(x, bins=bins)
binsize = np.diff(np.asfarray(bins))
hist = hist / binsize
ax.loglog(bins[1:], hist, 'ow', **kwargs)
return ax Example 34
def get_model():
if FLAGS.model == 'logistic':
return linear_model.LogisticRegressionCV(class_weight='balanced',
scoring='roc_auc',
n_jobs=FLAGS.n_jobs,
max_iter=10000, verbose=1)
elif FLAGS.model == 'random_forest':
return ensemble.RandomForestClassifier(n_estimators=100,
n_jobs=FLAGS.n_jobs,
class_weight='balanced',
verbose=1)
elif FLAGS.model == 'svm':
return grid_search.GridSearchCV(
estimator=svm.SVC(kernel='rbf', gamma='auto',
class_weight='balanced'),
param_grid={'C': np.logspace(-4, 4, 10)}, scoring='roc_auc',
n_jobs=FLAGS.n_jobs, verbose=1)
else:
raise ValueError('Unrecognized model %s' % FLAGS.model) Example 35
def __init__(self, model, ax=None, alphas=None,
cv=None, scoring=None, **kwargs):
# Check to make sure this is not a "RegressorCV"
name = model.__class__.__name__
if name.endswith("CV"):
raise YellowbrickTypeError((
"'{}' is a CV regularization model;"
" try AlphaSelection instead."
).format(name))
# Call super to initialize the class
super(ManualAlphaSelection, self).__init__(model, ax=ax, **kwargs)
# Set manual alpha selection parameters
self.alphas = alphas or np.logspace(-10, -2, 200)
self.errors = None
self.score_method = partial(cross_val_score, cv=cv, scoring=scoring) Example 36
def create_grid(self,abins=None,zbins=None):
if abins is None and zbins is None:
filenames = glob.glob(self.get_dirname()+'/%s_*.dat'%(self._prefix))
data = np.array([self.filename2params(f) for f in filenames])
if not len(data):
msg = "No isochrone files found in: %s"%self.get_dirname()
raise Exception(msg)
arange = np.unique(data[:,0])
zrange = np.unique(data[:,1])
elif abins is not None and zbins is not None:
# Age in units of Gyr
arange = np.linspace(abins[0],abins[1],abins[2]+1)
# Metallicity sampled logarithmically
zrange = np.logspace(np.log10(zbins[0]),np.log10(zbins[1]),zbins[2]+1)
else:
msg = "Must specify both `abins` and `zbins` or neither"
raise Exception(msg)
aa,zz = np.meshgrid(arange,zrange)
return aa.flatten(),zz.flatten() Example 37
def search_queue_params():
df = []
data_batch_sizes = np.logspace(0, 8, num=9, base=2, dtype=int)
capacities = np.logspace(0, 12, num=13, base=2, dtype=int)
nthreads = np.logspace(0, 5, num=6, base=2, dtype=int)
for nth in nthreads:
for data_batch_size in data_batch_sizes:
for capacity in capacities:
cap = nth * capacity
tf.reset_default_graph()
d = DataHDF5(batch_size=data_batch_size)
queue = data.Queue(d.node, d,
queue_type='fifo',
batch_size=BATCH_SIZE,
capacity=cap,
n_threads=nth)
queue.kind = '{} / {} / {}'.format(nth, data_batch_size, capacity)
durs = time_tf(queue)
durs['data batch size'] = data_batch_size
durs['queue capacity'] = cap
durs['nthreads'] = nth
df.append(durs)
d.cleanup()
df = pandas.concat(df, ignore_index=True)
df.kind = df.kind.astype('category', ordered=True, categories=df.kind.unique())
df.to_pickle('/home/qbilius/mh17/computed/search_queue_params.pkl')
print(df.groupby(['nthreads', 'data batch size', 'queue capacity']).dur.mean()) Example 38
def scaled_histogram(data, num_points, scale):
if scale == 'linear':
hist, edges = np.histogram(data, bins=max([5, int(num_points / 50)]))
else:
# Conditional catches an empty data input.
h1, h2 = ((np.log10(min(data)), np.log10(max(data))) if len(data) > 0 else (0, 1))
hist, edges = np.histogram(data, bins=np.logspace(h1, h2, 1 + max([5, int(num_points / 50)])))
hist_max = max(hist) * 1.1
return hist, edges, hist_max Example 39
def bernoulli_gaussian_trial(M=250,N=500,L=1000,pnz=.1,kappa=None,SNR=40):
A = np.random.normal(size=(M, N), scale=1.0 / math.sqrt(M)).astype(np.float32)
if kappa >= 1:
# create a random operator with a specific condition number
U,_,V = la.svd(A,full_matrices=False)
s = np.logspace( 0, np.log10( 1/kappa),M)
A = np.dot( U*(s*np.sqrt(N)/la.norm(s)),V).astype(np.float32)
A_ = tf.constant(A,name='A')
prob = TFGenerator(A=A,A_=A_,pnz=pnz,kappa=kappa,SNR=SNR)
prob.name = 'Bernoulli-Gaussian, random A'
bernoulli_ = tf.to_float( tf.random_uniform( (N,L) ) < pnz)
xgen_ = bernoulli_ * tf.random_normal( (N,L) )
noise_var = pnz*N/M * math.pow(10., -SNR / 10.)
ygen_ = tf.matmul( A_,xgen_) + tf.random_normal( (M,L),stddev=math.sqrt( noise_var ) )
prob.xval = ((np.random.uniform( 0,1,(N,L))<pnz) * np.random.normal(0,1,(N,L))).astype(np.float32)
prob.yval = np.matmul(A,prob.xval) + np.random.normal(0,math.sqrt( noise_var ),(M,L))
prob.xinit = ((np.random.uniform( 0,1,(N,L))<pnz) * np.random.normal(0,1,(N,L))).astype(np.float32)
prob.yinit = np.matmul(A,prob.xinit) + np.random.normal(0,math.sqrt( noise_var ),(M,L))
prob.xgen_ = xgen_
prob.ygen_ = ygen_
prob.noise_var = noise_var
return prob Example 40
def test_gradE(adjcube):
"""Tests the gradient of `E` using finite difference methods.
"""
from pydft.bases.fourier import gradE, E
from numpy.matlib import randn
cell = adjcube
V = QHO(cell)
Ns=4
#He set the random seed; we could do the same, but the
#implementation is probably different between numpy and matlab:
#randn('seed', 0.2004)
W = np.array(randn(np.prod(cell.S), Ns) + 1j*randn(np.prod(cell.S), Ns))
# Compute intial energy and gradient
E0 = E(V, W, cell)
g0 = gradE(V, W, cell)
# Choose a random direction to explore
dW = np.array(randn(W.shape) + 1j*randn(W.shape))
# Explore a range of step sizes decreasing by powers of ten
steps = np.logspace(np.log10(1e-3), np.log10(1e-7), 8)
for delta in steps:
# Directional derivative formula
dE = 2*np.real(np.trace(np.dot(g0.conjugate().T, delta*dW)))
# Print ratio of actual change to expected change, along with estimate
# of the error in this quantity due to rounding
ratio = abs(1.-(E(V, W+delta*dW, cell)-E0)/dE)
print(int(np.log10(ratio)), int(np.log10(delta)), ratio)
assert abs(int(np.log10(ratio)) - int(np.log10(delta))) <= 2 Example 41
def fcn_FDEM_InductionSpherePlaneWidget(xtx,ytx,ztx,m,orient,x0,y0,z0,a,sig,mur,xrx,yrx,zrx,logf,Comp,Phase):
sig = 10**sig
f = 10**logf
fvec = np.logspace(0,8,41)
xmin, xmax, dx, ymin, ymax, dy = -30., 30., 0.3, -30., 30., 0.4
X,Y = np.mgrid[xmin:xmax+dx:dx, ymin:ymax+dy:dy]
X = np.transpose(X)
Y = np.transpose(Y)
Obj = SphereFEM(m,orient,xtx,ytx,ztx)
Hx,Hy,Hz,Habs = Obj.fcn_ComputeFrequencyResponse(f,sig,mur,a,x0,y0,z0,X,Y,zrx)
Hxi,Hyi,Hzi,Habsi = Obj.fcn_ComputeFrequencyResponse(fvec,sig,mur,a,x0,y0,z0,xrx,yrx,zrx)
fig1 = plt.figure(figsize=(17,6))
Ax1 = fig1.add_axes([0.04,0,0.43,1])
Ax2 = fig1.add_axes([0.6,0,0.4,1])
if Comp == 'x':
Ax1 = plotAnomalyXYplane(Ax1,f,X,Y,ztx,Hx,Comp,Phase)
Ax1 = plotPlaceTxRxSphereXY(Ax1,xtx,ytx,xrx,yrx,x0,y0,a)
Ax2 = plotResponseFEM(Ax2,f,fvec,Hxi,Comp)
elif Comp == 'y':
Ax1 = plotAnomalyXYplane(Ax1,f,X,Y,ztx,Hy,Comp,Phase)
Ax1 = plotPlaceTxRxSphereXY(Ax1,xtx,ytx,xrx,yrx,x0,y0,a)
Ax2 = plotResponseFEM(Ax2,f,fvec,Hyi,Comp)
elif Comp == 'z':
Ax1 = plotAnomalyXYplane(Ax1,f,X,Y,ztx,Hz,Comp,Phase)
Ax1 = plotPlaceTxRxSphereXY(Ax1,xtx,ytx,xrx,yrx,x0,y0,a)
Ax2 = plotResponseFEM(Ax2,f,fvec,Hzi,Comp)
elif Comp == 'abs':
Ax1 = plotAnomalyXYplane(Ax1,f,X,Y,ztx,Habs,Comp,Phase)
Ax1 = plotPlaceTxRxSphereXY(Ax1,xtx,ytx,xrx,yrx,x0,y0,a)
Ax2 = plotResponseFEM(Ax2,f,fvec,Habsi,Comp)
plt.show(fig1) Example 42
def calc_IndCurrent_TD_offtime(self):
"""Gives FD induced current spectrum"""
#INITIALIZE ATTRIBUTES
Bpx = self.Bpx
Bpz = self.Bpz
a2 = self.a2
azm = np.pi*self.azm/180.
R = self.R
L = self.L
t = np.logspace(-6,0,101)
Ax = np.pi*a2**2*np.sin(azm)
Az = np.pi*a2**2*np.cos(azm)
Phi = (Ax*Bpx + Az*Bpz)
Is = (Phi/L)*np.exp(-(R/L)*t)
V = (Phi*R/L)*np.exp(-(R/L)*t) - (Phi*R/L**2)*np.exp(-(R/L)*t)
return V,Is
###########################################
# PLOTTING FUNCTIONS
########################################### Example 43
def plot_InducedCurrent_FD(self,Ax,Is,fi):
FS = 20
R = self.R
L = self.L
Imax = np.max(-np.real(Is))
f = np.logspace(0,8,101)
Ax.grid('both', linestyle='-', linewidth=0.8, color=[0.8, 0.8, 0.8])
Ax.semilogx(f,-np.real(Is),color='k',linewidth=4,label="$I_{Re}$")
Ax.semilogx(f,-np.imag(Is),color='k',ls='--',linewidth=4,label="$I_{Im}$")
Ax.semilogx(fi*np.array([1.,1.]),np.array([0,1.1*Imax]),color='r',ls='-',linewidth=3)
handles, labels = Ax.get_legend_handles_labels()
Ax.legend(handles, labels, loc='upper left', fontsize=FS)
Ax.set_xlabel('Frequency [Hz]',fontsize=FS+2)
Ax.set_ylabel('$\mathbf{- \, I_s (\omega)}$ [A]',fontsize=FS+2,labelpad=-10)
Ax.set_title('Frequency Response',fontsize=FS)
Ax.set_ybound(0,1.1*Imax)
Ax.tick_params(labelsize=FS-2)
Ax.yaxis.set_major_formatter(FormatStrFormatter('%.1e'))
#R_str = '{:.3e}'.format(R)
#L_str = '{:.3e}'.format(L)
#f_str = '{:.3e}'.format(fi)
#EMF_str = '{:.2e}j'.format(EMFi.imag)
#I_str = '{:.2e} - {:.2e}j'.format(float(np.real(Isi)),np.abs(float(np.imag(Isi))))
#Ax.text(1.4,1.01*Imax,'$R$ = '+R_str+' $\Omega$',fontsize=FS)
#Ax.text(1.4,0.94*Imax,'$L$ = '+L_str+' H',fontsize=FS)
#Ax.text(1.4,0.87*Imax,'$f$ = '+f_str+' Hz',fontsize=FS,color='r')
#Ax.text(1.4,0.8*Imax,'$V$ = '+EMF_str+' V',fontsize=FS,color='r')
#Ax.text(1.4,0.73*Imax,'$I_s$ = '+I_str+' A',fontsize=FS,color='r')
return Ax Example 44
def plot_InducedCurrent_TD(self,Ax,Is,ti,Vi,Isi):
FS = 20
R = self.R
L = self.L
Imax = np.max(Is)
t = np.logspace(-6,0,101)
Ax.grid('both', linestyle='-', linewidth=0.8, color=[0.8, 0.8, 0.8])
Ax.semilogx(t,Is,color='k',linewidth=4)
Ax.semilogx(ti*np.array([1.,1.]),np.array([0,1.3*Imax]),color='r',ls='-',linewidth=3)
Ax.set_xlabel('Time [s]',fontsize=FS+2)
Ax.set_ylabel('$\mathbf{I_s (\omega)}$ [A]',fontsize=FS+2,labelpad=-10)
Ax.set_title('Transient Induced Current',fontsize=FS)
Ax.set_ybound(0,1.2*Imax)
Ax.tick_params(labelsize=FS-2)
Ax.yaxis.set_major_formatter(FormatStrFormatter('%.1e'))
#R_str = '{:.3e}'.format(R)
#L_str = '{:.3e}'.format(L)
#t_str = '{:.3e}'.format(ti)
#V_str = '{:.3e}'.format(Vi)
#I_str = '{:.3e}'.format(Isi)
#Ax.text(1.4e-6,1.12*Imax,'$R$ = '+R_str+' $\Omega$',fontsize=FS)
#Ax.text(1.4e-6,1.04*Imax,'$L$ = '+L_str+' H',fontsize=FS)
#Ax.text(4e-2,1.12*Imax,'$t$ = '+t_str+' s',fontsize=FS,color='r')
#Ax.text(4e-2,1.04*Imax,'$V$ = '+V_str+' V',fontsize=FS,color='r')
#Ax.text(4e-2,0.96*Imax,'$I_s$ = '+I_str+' A',fontsize=FS,color='r')
return Ax Example 45
def __init__(self):
self.genMesh()
self.getCoreDomain()
# url = "http://em.geosci.xyz/_images/disc_dipole.png"
# response = requests.get(url)
# self.im = Image.open(StringIO(response.content))
self.time = np.logspace(-5, -2, 41) Example 46
def test_from_float_hex(self):
# IEEE doubles and floats only, otherwise the float32
# conversion may fail.
tgt = np.logspace(-10, 10, 5).astype(np.float32)
tgt = np.hstack((tgt, -tgt)).astype(np.float)
inp = '\n'.join(map(float.hex, tgt))
c = TextIO()
c.write(inp)
for dt in [np.float, np.float32]:
c.seek(0)
res = np.loadtxt(c, dtype=dt)
assert_equal(res, tgt, err_msg="%s" % dt) Example 47
def FrequencyAxis(Fmin, Fmax, Fnum, Log=True):
"""
Compute a lin/log spaced frequency axis.
"""
# Computing frequency axis
if Log:
Freq = _np.logspace(_np.log10(Fmin), _np.log10(Fmax), Fnum)
else:
Freq = _np.linspace(Fmin, Fmax, Fnum)
return Freq Example 48
def test_call(self):
"""Test that the bump EOS can be called
"""
bump_eos = EOSBump()
vol = np.logspace(np.log10(.1), np.log10(1), 50)
pressure = bump_eos(vol)
self.assertIsInstance(pressure, np.ndarray)
self.assertEqual(50, len(pressure)) Example 49
def test_derivative(self):
"""Test the derivative function
"""
bump_eos = EOSBump()
vol = np.logspace(np.log10(.1), np.log10(1), 50)
pressure = bump_eos.derivative()(vol)
self.assertIsInstance(pressure, np.ndarray)
self.assertEqual(50, len(pressure)) Example 50
def test_bad_derivative(self):
"""Tests that derivative errors are caught
"""
bump_eos = EOSBump()
vol = np.logspace(np.log10(.1), np.log10(1), 50)
with self.assertRaises(IOError):
pressure = bump_eos.derivative(order=2)(vol)
# end
p_fun = lambda v: 2.56e9 / v**3 