repo_name
stringlengths 6
112
| path
stringlengths 4
204
| copies
stringlengths 1
3
| size
stringlengths 4
6
| content
stringlengths 714
810k
| license
stringclasses 15
values |
|---|---|---|---|---|---|
appapantula/scikit-learn | benchmarks/bench_random_projections.py | 397 | 8900 | """
===========================
Random projection benchmark
===========================
Benchmarks for random projections.
"""
from __future__ import division
from __future__ import print_function
import gc
import sys
import optparse
from datetime import datetime
import collections
import numpy as np
import scipy.sparse as sp
from sklearn import clone
from sklearn.externals.six.moves import xrange
from sklearn.random_projection import (SparseRandomProjection,
GaussianRandomProjection,
johnson_lindenstrauss_min_dim)
def type_auto_or_float(val):
if val == "auto":
return "auto"
else:
return float(val)
def type_auto_or_int(val):
if val == "auto":
return "auto"
else:
return int(val)
def compute_time(t_start, delta):
mu_second = 0.0 + 10 ** 6 # number of microseconds in a second
return delta.seconds + delta.microseconds / mu_second
def bench_scikit_transformer(X, transfomer):
gc.collect()
clf = clone(transfomer)
# start time
t_start = datetime.now()
clf.fit(X)
delta = (datetime.now() - t_start)
# stop time
time_to_fit = compute_time(t_start, delta)
# start time
t_start = datetime.now()
clf.transform(X)
delta = (datetime.now() - t_start)
# stop time
time_to_transform = compute_time(t_start, delta)
return time_to_fit, time_to_transform
# Make some random data with uniformly located non zero entries with
# Gaussian distributed values
def make_sparse_random_data(n_samples, n_features, n_nonzeros,
random_state=None):
rng = np.random.RandomState(random_state)
data_coo = sp.coo_matrix(
(rng.randn(n_nonzeros),
(rng.randint(n_samples, size=n_nonzeros),
rng.randint(n_features, size=n_nonzeros))),
shape=(n_samples, n_features))
return data_coo.toarray(), data_coo.tocsr()
def print_row(clf_type, time_fit, time_transform):
print("%s | %s | %s" % (clf_type.ljust(30),
("%.4fs" % time_fit).center(12),
("%.4fs" % time_transform).center(12)))
if __name__ == "__main__":
###########################################################################
# Option parser
###########################################################################
op = optparse.OptionParser()
op.add_option("--n-times",
dest="n_times", default=5, type=int,
help="Benchmark results are average over n_times experiments")
op.add_option("--n-features",
dest="n_features", default=10 ** 4, type=int,
help="Number of features in the benchmarks")
op.add_option("--n-components",
dest="n_components", default="auto",
help="Size of the random subspace."
" ('auto' or int > 0)")
op.add_option("--ratio-nonzeros",
dest="ratio_nonzeros", default=10 ** -3, type=float,
help="Number of features in the benchmarks")
op.add_option("--n-samples",
dest="n_samples", default=500, type=int,
help="Number of samples in the benchmarks")
op.add_option("--random-seed",
dest="random_seed", default=13, type=int,
help="Seed used by the random number generators.")
op.add_option("--density",
dest="density", default=1 / 3,
help="Density used by the sparse random projection."
" ('auto' or float (0.0, 1.0]")
op.add_option("--eps",
dest="eps", default=0.5, type=float,
help="See the documentation of the underlying transformers.")
op.add_option("--transformers",
dest="selected_transformers",
default='GaussianRandomProjection,SparseRandomProjection',
type=str,
help="Comma-separated list of transformer to benchmark. "
"Default: %default. Available: "
"GaussianRandomProjection,SparseRandomProjection")
op.add_option("--dense",
dest="dense",
default=False,
action="store_true",
help="Set input space as a dense matrix.")
(opts, args) = op.parse_args()
if len(args) > 0:
op.error("this script takes no arguments.")
sys.exit(1)
opts.n_components = type_auto_or_int(opts.n_components)
opts.density = type_auto_or_float(opts.density)
selected_transformers = opts.selected_transformers.split(',')
###########################################################################
# Generate dataset
###########################################################################
n_nonzeros = int(opts.ratio_nonzeros * opts.n_features)
print('Dataset statics')
print("===========================")
print('n_samples \t= %s' % opts.n_samples)
print('n_features \t= %s' % opts.n_features)
if opts.n_components == "auto":
print('n_components \t= %s (auto)' %
johnson_lindenstrauss_min_dim(n_samples=opts.n_samples,
eps=opts.eps))
else:
print('n_components \t= %s' % opts.n_components)
print('n_elements \t= %s' % (opts.n_features * opts.n_samples))
print('n_nonzeros \t= %s per feature' % n_nonzeros)
print('ratio_nonzeros \t= %s' % opts.ratio_nonzeros)
print('')
###########################################################################
# Set transformer input
###########################################################################
transformers = {}
###########################################################################
# Set GaussianRandomProjection input
gaussian_matrix_params = {
"n_components": opts.n_components,
"random_state": opts.random_seed
}
transformers["GaussianRandomProjection"] = \
GaussianRandomProjection(**gaussian_matrix_params)
###########################################################################
# Set SparseRandomProjection input
sparse_matrix_params = {
"n_components": opts.n_components,
"random_state": opts.random_seed,
"density": opts.density,
"eps": opts.eps,
}
transformers["SparseRandomProjection"] = \
SparseRandomProjection(**sparse_matrix_params)
###########################################################################
# Perform benchmark
###########################################################################
time_fit = collections.defaultdict(list)
time_transform = collections.defaultdict(list)
print('Benchmarks')
print("===========================")
print("Generate dataset benchmarks... ", end="")
X_dense, X_sparse = make_sparse_random_data(opts.n_samples,
opts.n_features,
n_nonzeros,
random_state=opts.random_seed)
X = X_dense if opts.dense else X_sparse
print("done")
for name in selected_transformers:
print("Perform benchmarks for %s..." % name)
for iteration in xrange(opts.n_times):
print("\titer %s..." % iteration, end="")
time_to_fit, time_to_transform = bench_scikit_transformer(X_dense,
transformers[name])
time_fit[name].append(time_to_fit)
time_transform[name].append(time_to_transform)
print("done")
print("")
###########################################################################
# Print results
###########################################################################
print("Script arguments")
print("===========================")
arguments = vars(opts)
print("%s \t | %s " % ("Arguments".ljust(16),
"Value".center(12),))
print(25 * "-" + ("|" + "-" * 14) * 1)
for key, value in arguments.items():
print("%s \t | %s " % (str(key).ljust(16),
str(value).strip().center(12)))
print("")
print("Transformer performance:")
print("===========================")
print("Results are averaged over %s repetition(s)." % opts.n_times)
print("")
print("%s | %s | %s" % ("Transformer".ljust(30),
"fit".center(12),
"transform".center(12)))
print(31 * "-" + ("|" + "-" * 14) * 2)
for name in sorted(selected_transformers):
print_row(name,
np.mean(time_fit[name]),
np.mean(time_transform[name]))
print("")
print("")
| bsd-3-clause |
thilbern/scikit-learn | examples/cluster/plot_ward_structured_vs_unstructured.py | 29 | 3349 | """
===========================================================
Hierarchical clustering: structured vs unstructured ward
===========================================================
Example builds a swiss roll dataset and runs
hierarchical clustering on their position.
For more information, see :ref:`hierarchical_clustering`.
In a first step, the hierarchical clustering is performed without connectivity
constraints on the structure and is solely based on distance, whereas in
a second step the clustering is restricted to the k-Nearest Neighbors
graph: it's a hierarchical clustering with structure prior.
Some of the clusters learned without connectivity constraints do not
respect the structure of the swiss roll and extend across different folds of
the manifolds. On the opposite, when opposing connectivity constraints,
the clusters form a nice parcellation of the swiss roll.
"""
# Authors : Vincent Michel, 2010
# Alexandre Gramfort, 2010
# Gael Varoquaux, 2010
# License: BSD 3 clause
print(__doc__)
import time as time
import numpy as np
import matplotlib.pyplot as plt
import mpl_toolkits.mplot3d.axes3d as p3
from sklearn.cluster import AgglomerativeClustering
from sklearn.datasets.samples_generator import make_swiss_roll
###############################################################################
# Generate data (swiss roll dataset)
n_samples = 1500
noise = 0.05
X, _ = make_swiss_roll(n_samples, noise)
# Make it thinner
X[:, 1] *= .5
###############################################################################
# Compute clustering
print("Compute unstructured hierarchical clustering...")
st = time.time()
ward = AgglomerativeClustering(n_clusters=6, linkage='ward').fit(X)
elapsed_time = time.time() - st
label = ward.labels_
print("Elapsed time: %.2fs" % elapsed_time)
print("Number of points: %i" % label.size)
###############################################################################
# Plot result
fig = plt.figure()
ax = p3.Axes3D(fig)
ax.view_init(7, -80)
for l in np.unique(label):
ax.plot3D(X[label == l, 0], X[label == l, 1], X[label == l, 2],
'o', color=plt.cm.jet(np.float(l) / np.max(label + 1)))
plt.title('Without connectivity constraints (time %.2fs)' % elapsed_time)
###############################################################################
# Define the structure A of the data. Here a 10 nearest neighbors
from sklearn.neighbors import kneighbors_graph
connectivity = kneighbors_graph(X, n_neighbors=10)
###############################################################################
# Compute clustering
print("Compute structured hierarchical clustering...")
st = time.time()
ward = AgglomerativeClustering(n_clusters=6, connectivity=connectivity,
linkage='ward').fit(X)
elapsed_time = time.time() - st
label = ward.labels_
print("Elapsed time: %.2fs" % elapsed_time)
print("Number of points: %i" % label.size)
###############################################################################
# Plot result
fig = plt.figure()
ax = p3.Axes3D(fig)
ax.view_init(7, -80)
for l in np.unique(label):
ax.plot3D(X[label == l, 0], X[label == l, 1], X[label == l, 2],
'o', color=plt.cm.jet(float(l) / np.max(label + 1)))
plt.title('With connectivity constraints (time %.2fs)' % elapsed_time)
plt.show()
| bsd-3-clause |
cjayb/mne-python | tutorials/machine-learning/plot_receptive_field.py | 8 | 15220 | # -*- coding: utf-8 -*-
"""
=====================================================================
Spectro-temporal receptive field (STRF) estimation on continuous data
=====================================================================
This demonstrates how an encoding model can be fit with multiple continuous
inputs. In this case, we simulate the model behind a spectro-temporal receptive
field (or STRF). First, we create a linear filter that maps patterns in
spectro-temporal space onto an output, representing neural activity. We fit
a receptive field model that attempts to recover the original linear filter
that was used to create this data.
References
----------
Estimation of spectro-temporal and spatio-temporal receptive fields using
modeling with continuous inputs is described in:
.. [1] Theunissen, F. E. et al. Estimating spatio-temporal receptive
fields of auditory and visual neurons from their responses to
natural stimuli. Network 12, 289-316 (2001).
.. [2] Willmore, B. & Smyth, D. Methods for first-order kernel
estimation: simple-cell receptive fields from responses to
natural scenes. Network 14, 553-77 (2003).
.. [3] Crosse, M. J., Di Liberto, G. M., Bednar, A. & Lalor, E. C. (2016).
The Multivariate Temporal Response Function (mTRF) Toolbox:
A MATLAB Toolbox for Relating Neural Signals to Continuous Stimuli.
Frontiers in Human Neuroscience 10, 604.
doi:10.3389/fnhum.2016.00604
.. [4] Holdgraf, C. R. et al. Rapid tuning shifts in human auditory cortex
enhance speech intelligibility. Nature Communications, 7, 13654 (2016).
doi:10.1038/ncomms13654
"""
# Authors: Chris Holdgraf <[email protected]>
# Eric Larson <[email protected]>
#
# License: BSD (3-clause)
# sphinx_gallery_thumbnail_number = 7
import numpy as np
import matplotlib.pyplot as plt
import mne
from mne.decoding import ReceptiveField, TimeDelayingRidge
from scipy.stats import multivariate_normal
from scipy.io import loadmat
from sklearn.preprocessing import scale
rng = np.random.RandomState(1337) # To make this example reproducible
###############################################################################
# Load audio data
# ---------------
#
# We'll read in the audio data from [3]_ in order to simulate a response.
#
# In addition, we'll downsample the data along the time dimension in order to
# speed up computation. Note that depending on the input values, this may
# not be desired. For example if your input stimulus varies more quickly than
# 1/2 the sampling rate to which we are downsampling.
# Read in audio that's been recorded in epochs.
path_audio = mne.datasets.mtrf.data_path()
data = loadmat(path_audio + '/speech_data.mat')
audio = data['spectrogram'].T
sfreq = float(data['Fs'][0, 0])
n_decim = 2
audio = mne.filter.resample(audio, down=n_decim, npad='auto')
sfreq /= n_decim
###############################################################################
# Create a receptive field
# ------------------------
#
# We'll simulate a linear receptive field for a theoretical neural signal. This
# defines how the signal will respond to power in this receptive field space.
n_freqs = 20
tmin, tmax = -0.1, 0.4
# To simulate the data we'll create explicit delays here
delays_samp = np.arange(np.round(tmin * sfreq),
np.round(tmax * sfreq) + 1).astype(int)
delays_sec = delays_samp / sfreq
freqs = np.linspace(50, 5000, n_freqs)
grid = np.array(np.meshgrid(delays_sec, freqs))
# We need data to be shaped as n_epochs, n_features, n_times, so swap axes here
grid = grid.swapaxes(0, -1).swapaxes(0, 1)
# Simulate a temporal receptive field with a Gabor filter
means_high = [.1, 500]
means_low = [.2, 2500]
cov = [[.001, 0], [0, 500000]]
gauss_high = multivariate_normal.pdf(grid, means_high, cov)
gauss_low = -1 * multivariate_normal.pdf(grid, means_low, cov)
weights = gauss_high + gauss_low # Combine to create the "true" STRF
kwargs = dict(vmax=np.abs(weights).max(), vmin=-np.abs(weights).max(),
cmap='RdBu_r', shading='gouraud')
fig, ax = plt.subplots()
ax.pcolormesh(delays_sec, freqs, weights, **kwargs)
ax.set(title='Simulated STRF', xlabel='Time Lags (s)', ylabel='Frequency (Hz)')
plt.setp(ax.get_xticklabels(), rotation=45)
plt.autoscale(tight=True)
mne.viz.tight_layout()
###############################################################################
# Simulate a neural response
# --------------------------
#
# Using this receptive field, we'll create an artificial neural response to
# a stimulus.
#
# To do this, we'll create a time-delayed version of the receptive field, and
# then calculate the dot product between this and the stimulus. Note that this
# is effectively doing a convolution between the stimulus and the receptive
# field. See `here <https://en.wikipedia.org/wiki/Convolution>`_ for more
# information.
# Reshape audio to split into epochs, then make epochs the first dimension.
n_epochs, n_seconds = 16, 5
audio = audio[:, :int(n_seconds * sfreq * n_epochs)]
X = audio.reshape([n_freqs, n_epochs, -1]).swapaxes(0, 1)
n_times = X.shape[-1]
# Delay the spectrogram according to delays so it can be combined w/ the STRF
# Lags will now be in axis 1, then we reshape to vectorize
delays = np.arange(np.round(tmin * sfreq),
np.round(tmax * sfreq) + 1).astype(int)
# Iterate through indices and append
X_del = np.zeros((len(delays),) + X.shape)
for ii, ix_delay in enumerate(delays):
# These arrays will take/put particular indices in the data
take = [slice(None)] * X.ndim
put = [slice(None)] * X.ndim
if ix_delay > 0:
take[-1] = slice(None, -ix_delay)
put[-1] = slice(ix_delay, None)
elif ix_delay < 0:
take[-1] = slice(-ix_delay, None)
put[-1] = slice(None, ix_delay)
X_del[ii][tuple(put)] = X[tuple(take)]
# Now set the delayed axis to the 2nd dimension
X_del = np.rollaxis(X_del, 0, 3)
X_del = X_del.reshape([n_epochs, -1, n_times])
n_features = X_del.shape[1]
weights_sim = weights.ravel()
# Simulate a neural response to the sound, given this STRF
y = np.zeros((n_epochs, n_times))
for ii, iep in enumerate(X_del):
# Simulate this epoch and add random noise
noise_amp = .002
y[ii] = np.dot(weights_sim, iep) + noise_amp * rng.randn(n_times)
# Plot the first 2 trials of audio and the simulated electrode activity
X_plt = scale(np.hstack(X[:2]).T).T
y_plt = scale(np.hstack(y[:2]))
time = np.arange(X_plt.shape[-1]) / sfreq
_, (ax1, ax2) = plt.subplots(2, 1, figsize=(6, 6), sharex=True)
ax1.pcolormesh(time, freqs, X_plt, vmin=0, vmax=4, cmap='Reds',
shading='gouraud')
ax1.set_title('Input auditory features')
ax1.set(ylim=[freqs.min(), freqs.max()], ylabel='Frequency (Hz)')
ax2.plot(time, y_plt)
ax2.set(xlim=[time.min(), time.max()], title='Simulated response',
xlabel='Time (s)', ylabel='Activity (a.u.)')
mne.viz.tight_layout()
###############################################################################
# Fit a model to recover this receptive field
# -------------------------------------------
#
# Finally, we'll use the :class:`mne.decoding.ReceptiveField` class to recover
# the linear receptive field of this signal. Note that properties of the
# receptive field (e.g. smoothness) will depend on the autocorrelation in the
# inputs and outputs.
# Create training and testing data
train, test = np.arange(n_epochs - 1), n_epochs - 1
X_train, X_test, y_train, y_test = X[train], X[test], y[train], y[test]
X_train, X_test, y_train, y_test = [np.rollaxis(ii, -1, 0) for ii in
(X_train, X_test, y_train, y_test)]
# Model the simulated data as a function of the spectrogram input
alphas = np.logspace(-3, 3, 7)
scores = np.zeros_like(alphas)
models = []
for ii, alpha in enumerate(alphas):
rf = ReceptiveField(tmin, tmax, sfreq, freqs, estimator=alpha)
rf.fit(X_train, y_train)
# Now make predictions about the model output, given input stimuli.
scores[ii] = rf.score(X_test, y_test)
models.append(rf)
times = rf.delays_ / float(rf.sfreq)
# Choose the model that performed best on the held out data
ix_best_alpha = np.argmax(scores)
best_mod = models[ix_best_alpha]
coefs = best_mod.coef_[0]
best_pred = best_mod.predict(X_test)[:, 0]
# Plot the original STRF, and the one that we recovered with modeling.
_, (ax1, ax2) = plt.subplots(1, 2, figsize=(6, 3), sharey=True, sharex=True)
ax1.pcolormesh(delays_sec, freqs, weights, **kwargs)
ax2.pcolormesh(times, rf.feature_names, coefs, **kwargs)
ax1.set_title('Original STRF')
ax2.set_title('Best Reconstructed STRF')
plt.setp([iax.get_xticklabels() for iax in [ax1, ax2]], rotation=45)
plt.autoscale(tight=True)
mne.viz.tight_layout()
# Plot the actual response and the predicted response on a held out stimulus
time_pred = np.arange(best_pred.shape[0]) / sfreq
fig, ax = plt.subplots()
ax.plot(time_pred, y_test, color='k', alpha=.2, lw=4)
ax.plot(time_pred, best_pred, color='r', lw=1)
ax.set(title='Original and predicted activity', xlabel='Time (s)')
ax.legend(['Original', 'Predicted'])
plt.autoscale(tight=True)
mne.viz.tight_layout()
###############################################################################
# Visualize the effects of regularization
# ---------------------------------------
#
# Above we fit a :class:`mne.decoding.ReceptiveField` model for one of many
# values for the ridge regularization parameter. Here we will plot the model
# score as well as the model coefficients for each value, in order to
# visualize how coefficients change with different levels of regularization.
# These issues as well as the STRF pipeline are described in detail
# in [1]_, [2]_, and [4]_.
# Plot model score for each ridge parameter
fig = plt.figure(figsize=(10, 4))
ax = plt.subplot2grid([2, len(alphas)], [1, 0], 1, len(alphas))
ax.plot(np.arange(len(alphas)), scores, marker='o', color='r')
ax.annotate('Best parameter', (ix_best_alpha, scores[ix_best_alpha]),
(ix_best_alpha, scores[ix_best_alpha] - .1),
arrowprops={'arrowstyle': '->'})
plt.xticks(np.arange(len(alphas)), ["%.0e" % ii for ii in alphas])
ax.set(xlabel="Ridge regularization value", ylabel="Score ($R^2$)",
xlim=[-.4, len(alphas) - .6])
mne.viz.tight_layout()
# Plot the STRF of each ridge parameter
for ii, (rf, i_alpha) in enumerate(zip(models, alphas)):
ax = plt.subplot2grid([2, len(alphas)], [0, ii], 1, 1)
ax.pcolormesh(times, rf.feature_names, rf.coef_[0], **kwargs)
plt.xticks([], [])
plt.yticks([], [])
plt.autoscale(tight=True)
fig.suptitle('Model coefficients / scores for many ridge parameters', y=1)
mne.viz.tight_layout()
###############################################################################
# Using different regularization types
# ------------------------------------
# In addition to the standard ridge regularization, the
# :class:`mne.decoding.TimeDelayingRidge` class also exposes
# `Laplacian <https://en.wikipedia.org/wiki/Laplacian_matrix>`_ regularization
# term as:
#
# .. math::
# \left[\begin{matrix}
# 1 & -1 & & & & \\
# -1 & 2 & -1 & & & \\
# & -1 & 2 & -1 & & \\
# & & \ddots & \ddots & \ddots & \\
# & & & -1 & 2 & -1 \\
# & & & & -1 & 1\end{matrix}\right]
#
# This imposes a smoothness constraint of nearby time samples and/or features.
# Quoting [3]_:
#
# Tikhonov [identity] regularization (Equation 5) reduces overfitting by
# smoothing the TRF estimate in a way that is insensitive to
# the amplitude of the signal of interest. However, the Laplacian
# approach (Equation 6) reduces off-sample error whilst preserving
# signal amplitude (Lalor et al., 2006). As a result, this approach
# usually leads to an improved estimate of the system’s response (as
# indexed by MSE) compared to Tikhonov regularization.
#
scores_lap = np.zeros_like(alphas)
models_lap = []
for ii, alpha in enumerate(alphas):
estimator = TimeDelayingRidge(tmin, tmax, sfreq, reg_type='laplacian',
alpha=alpha)
rf = ReceptiveField(tmin, tmax, sfreq, freqs, estimator=estimator)
rf.fit(X_train, y_train)
# Now make predictions about the model output, given input stimuli.
scores_lap[ii] = rf.score(X_test, y_test)
models_lap.append(rf)
ix_best_alpha_lap = np.argmax(scores_lap)
###############################################################################
# Compare model performance
# -------------------------
# Below we visualize the model performance of each regularization method
# (ridge vs. Laplacian) for different levels of alpha. As you can see, the
# Laplacian method performs better in general, because it imposes a smoothness
# constraint along the time and feature dimensions of the coefficients.
# This matches the "true" receptive field structure and results in a better
# model fit.
fig = plt.figure(figsize=(10, 6))
ax = plt.subplot2grid([3, len(alphas)], [2, 0], 1, len(alphas))
ax.plot(np.arange(len(alphas)), scores_lap, marker='o', color='r')
ax.plot(np.arange(len(alphas)), scores, marker='o', color='0.5', ls=':')
ax.annotate('Best Laplacian', (ix_best_alpha_lap,
scores_lap[ix_best_alpha_lap]),
(ix_best_alpha_lap, scores_lap[ix_best_alpha_lap] - .1),
arrowprops={'arrowstyle': '->'})
ax.annotate('Best Ridge', (ix_best_alpha, scores[ix_best_alpha]),
(ix_best_alpha, scores[ix_best_alpha] - .1),
arrowprops={'arrowstyle': '->'})
plt.xticks(np.arange(len(alphas)), ["%.0e" % ii for ii in alphas])
ax.set(xlabel="Laplacian regularization value", ylabel="Score ($R^2$)",
xlim=[-.4, len(alphas) - .6])
mne.viz.tight_layout()
# Plot the STRF of each ridge parameter
xlim = times[[0, -1]]
for ii, (rf_lap, rf, i_alpha) in enumerate(zip(models_lap, models, alphas)):
ax = plt.subplot2grid([3, len(alphas)], [0, ii], 1, 1)
ax.pcolormesh(times, rf_lap.feature_names, rf_lap.coef_[0], **kwargs)
ax.set(xticks=[], yticks=[], xlim=xlim)
if ii == 0:
ax.set(ylabel='Laplacian')
ax = plt.subplot2grid([3, len(alphas)], [1, ii], 1, 1)
ax.pcolormesh(times, rf.feature_names, rf.coef_[0], **kwargs)
ax.set(xticks=[], yticks=[], xlim=xlim)
if ii == 0:
ax.set(ylabel='Ridge')
fig.suptitle('Model coefficients / scores for laplacian regularization', y=1)
mne.viz.tight_layout()
###############################################################################
# Plot the original STRF, and the one that we recovered with modeling.
rf = models[ix_best_alpha]
rf_lap = models_lap[ix_best_alpha_lap]
_, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(9, 3),
sharey=True, sharex=True)
ax1.pcolormesh(delays_sec, freqs, weights, **kwargs)
ax2.pcolormesh(times, rf.feature_names, rf.coef_[0], **kwargs)
ax3.pcolormesh(times, rf_lap.feature_names, rf_lap.coef_[0], **kwargs)
ax1.set_title('Original STRF')
ax2.set_title('Best Ridge STRF')
ax3.set_title('Best Laplacian STRF')
plt.setp([iax.get_xticklabels() for iax in [ax1, ax2, ax3]], rotation=45)
plt.autoscale(tight=True)
mne.viz.tight_layout()
| bsd-3-clause |
COMP90024CloudComputing/Submit_Cloud_Computing | search/rest_bris.py | 1 | 5189 | import tweepy
import json
import couchdb
import jsonpickle
import sys,os
import time
from textblob import TextBlob
import requests
import matplotlib.pyplot as plt
from matplotlib.path import Path
import matplotlib.patches as patches
import matplotlib.path as mplPath
import numpy as np
import socket
maxTweets = 10000000 # Some arbitrary large number
tweetsPerQry = 100 # this is the max the API permits
tweetCount = 0
#create socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('127.0.0.1', 9999))
print "Connect to socket"
print s.recv(1024)
oauth_keys = [["eNaOt7MW9SUk7zuPQpCrbXTBC", "agxEVyN5z6HtIv9LAK6CNmSU3dH194BMkuALb5oI9PU4Ui5dzK", "855999502255247360-Re3ewycQBkVi08w0rb1sp9bB40cLouA", "nisiRGg3tO50EMmbaU6MvAhnXYXe3FcQ0sjzkolDEPTyV"],
["ahAzM3Wvh4YITVM60G65ZuOpP", "NbWxlbuBsoDA4HELYWlyylY0RASjm0Gtbmsn9Vzbx10ZFXDAGv", "855999502255247360-BjSm0tFrw3v3um0QTRJ0wAvmhiy7cme", "kRUY3kM5MbBNryRDMA20EN7CNE7lSdJEg3FO3z7Omm1BH"],
["YFwd6NZlPBEm2Nu7VUs7eOXva", "ACa2A3C4RrV2TaSa9v1KF3ruO0zSZBC91RPYDh6K1XzYDY8rry", "855999502255247360-p93VgBZJIdb9254jAiCWzxCJ6RFJsLE", "Yrp1QszXQ2NUXJExQC4NR42ew4t7FpHKVD6EpJK8PBFZL"],
["ZQGDhawy20pPmyQmKQ79CtVNu", "Y1goSHJTe70CalKKBhT7EnGgkmiffnevmEvwG34z7IRjVVbBfb", "855999502255247360-wcivhMiEXhZHw5zyDJe0QhulwLaPFUW", "pvWGE9jNQyeHLnnMFkTbXniorXIjlDKuTDBxEPQRkLfXH"],
["ibSGx30BljiLofBRtS77AFETt", "4g2H14S8ugsPme1jELA6Y4O9RR5Sf8EElPLH96F5A8XFarl8VM", "855999502255247360-mwwO3oTq9TKhixLA8Exke4vgV1CnyfD", "med3gQXEWkKQtyC84zSDPIgCH3o2WrHGIx7fliTk6sJEf"]]
auths = []
for consumer_key, consumer_secret, access_key, access_secret in oauth_keys:
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
auths.append(auth)
#Pass our consumer key and consumer secret to Tweepy's user authentication handler
#auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
#Pass our access token and access secret to Tweepy's user authentication handler
#auth.set_access_token(access_token, access_secret)
#Creating a twitter API wrapper using tweepy
# If results from a specific ID onwards are reqd, set since_id to that ID.
# else default to no lower limit, go as far back as API allows
sinceId = None
# If results only below a specific ID are, set max_id to that ID.
# else default to no upper limit, start from the most recent tweet matching the search query.
max_id = -1L
switch = 0
while tweetCount < maxTweets:
api = tweepy.API(auths[switch], #monitor_rate_limit=True,
#retry_count=10000, retry_delay=5,
# retry_errors=set([401, 404, 500, 503]),
#wait_on_rate_limit=True,
wait_on_rate_limit_notify=True)
#Error handling
if (not api):
print ("Problem connecting to API")
try:
if max_id <= 0:
if (not sinceId):
new_tweets = api.search(q="place:004ec16c62325149", count=tweetsPerQry)
else:
new_tweets = api.search(q="place:004ec16c62325149", count=tweetsPerQry,
since_id=sinceId)
else:
if (not sinceId):
new_tweets = api.search(q="place:004ec16c62325149", count=tweetsPerQry,
max_id=str(max_id - 1))
else:
new_tweets = api.search(q="place:004ec16c62325149", count=tweetsPerQry,
max_id=str(max_id - 1),
since_id=sinceId)
if not new_tweets:
print "No more tweets found"
time.sleep(180)
for tweet in new_tweets:
#Load tweets and send to analysis server
data = json.loads(jsonpickle.encode(tweet._json))
_id = data['id']
text = str(data['text'].encode('ascii','ignore'))
lang = str(data['lang'].encode('ascii'))
created_at = str(data['created_at'].encode('ascii'))
coordinates = "null"
if data['coordinates'] != None:
coordinates = data['coordinates']['coordinates']
else:
print "No coordinate"
place = str(data['place']['full_name'].encode('ascii'))
is_finance = 'false'
send_data = {'id':_id, 'text':text, 'lang':lang, 'created_at':created_at, 'coordinates':coordinates, 'place':place, 'is_finance':is_finance}
send_date_string = json.dumps(send_data)
print "send data"
s.send(send_date_string)
print " Send data success"
tweetCount += len(new_tweets)
try:
max_id = new_tweets[-1].id
except :
continue
print("Downloaded {0} tweets in Brisbane".format(tweetCount))
except tweepy.TweepError as e:
print "switching keys...bris"
switch += 1
if switch > 4:
print "Limit reached"
switch = 0
time.sleep(180)
continue
except StopIteration:
break
| apache-2.0 |
WafaaT/spark-tk | regression-tests/sparktkregtests/testcases/dicom/dicom_filter_test.py | 13 | 10428 | # vim: set encoding=utf-8
# Copyright (c) 2016 Intel Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
"""tests dicom.filter functionality"""
import unittest
from sparktkregtests.lib import sparktk_test
import os
import dicom
import numpy
import random
from lxml import etree
import datetime
class DicomFilterTest(sparktk_test.SparkTKTestCase):
def setUp(self):
"""import dicom data for testing"""
super(DicomFilterTest, self).setUp()
self.dataset = self.get_file("dicom_uncompressed")
self.dicom = self.context.dicom.import_dcm(self.dataset)
self.xml_directory = "../../../datasets/dicom/dicom_uncompressed/xml/"
self.image_directory = "../../../datasets/dicom/dicom_uncompressed/imagedata/"
self.query = ".//DicomAttribute[@keyword='KEYWORD']/Value/text()"
self.count = self.dicom.metadata.count()
def test_filter_one_key(self):
"""test filter with basic filter function"""
# extract a key-value pair from the first row metadata for our use
first_row = self.dicom.metadata.to_pandas()["metadata"][0]
xml = etree.fromstring(first_row.encode("ascii", "ignore"))
patient_id = xml.xpath(self.query.replace("KEYWORD", "PatientID"))[0]
# ask dicom to filter using our key-value filter function
self.dicom.filter(self._filter_key_values({ "PatientID" : patient_id }))
# we generate our own result to compare to dicom's
expected_result = self._filter({ "PatientID" : patient_id })
# ensure results match
self._compare_dicom_with_expected_result(expected_result)
def test_filter_multi_key(self):
"""test filter with basic filter function mult keyval pairs"""
# first we extract key-value pairs from the first row's metadata
# for our own use to generate a key-val dictionary
first_row = self.dicom.metadata.to_pandas()["metadata"][0]
xml = etree.fromstring(first_row.encode("ascii", "ignore"))
patient_id = xml.xpath(self.query.replace("KEYWORD", "PatientID"))[0]
sopi_id = xml.xpath(self.query.replace("KEYWORD", "SOPInstanceUID"))[0]
key_val = { "PatientID" : patient_id, "SOPInstanceUID" : sopi_id }
# we use our filter function and ask dicom to filter
self.dicom.filter(self._filter_key_values(key_val))
# here we generate our own result
expected_result = self._filter(key_val)
# compare expected result to what dicom gave us
self._compare_dicom_with_expected_result(expected_result)
def test_filter_zero_matching_records(self):
"""test filter with filter function returns none"""
# we give dicom a filter function which filters by
# key-value and give it a key-value pair which will
# return 0 records
pandas = self.dicom.metadata.to_pandas()
self.dicom.filter(self._filter_key_values({ "PatientID" : -6 }))
self.assertEqual(0, self.dicom.metadata.count())
def test_filter_nothing(self):
"""test filter with filter function filters nothing"""
# this filter function will return all records
self.dicom.filter(self._filter_nothing())
self.assertEqual(self.dicom.metadata.count(), self.count)
def test_filter_everything(self):
"""test filter function filter everything"""
# filter_everything filter out all of the records
self.dicom.filter(self._filter_everything())
self.assertEqual(0, self.dicom.metadata.count())
def test_filter_timestamp_range(self):
"""test filter with timestamp range function"""
# we will test filter with a function which takes a begin and end
# date and returns all records with a study date between them
# we will set begin date to 15 years ago and end date to 5 years ago
begin_date = datetime.datetime.now() - datetime.timedelta(days=15*365)
end_date = datetime.datetime.now() - datetime.timedelta(days=5*365)
# here we will generate our own result by filtering for records
# which meet our criteria
expected_result = []
pandas = self.dicom.metadata.to_pandas()
# iterate through the rows and append all records with
# a study date between our begin and end date
for index, row in pandas.iterrows():
ascii_row = row["metadata"].encode("ascii", "ignore")
xml_root = etree.fromstring(ascii_row)
study_date = xml_root.xpath(self.query.replace("KEYWORD", "StudyDate"))[0]
datetime_study_date = datetime.datetime.strptime(study_date, "%Y%m%d")
if datetime_study_date > begin_date and datetime_study_date < end_date:
expected_result.append(ascii_row)
# now we ask dicom to use our filter function below to return
# all records with a StudyDate within our specified range
self.dicom.filter(self._filter_timestamp_range(begin_date, end_date))
# ensure that expected result matches actual
self._compare_dicom_with_expected_result(expected_result)
def test_return_type_str(self):
"""test filter with function that returns strings"""
self.dicom.filter(self._filter_return_string())
self.assertEqual(3, self.dicom.metadata.count())
def test_return_type_int(self):
"""test filter wtih function that returns ints"""
self.dicom.filter(self._filter_return_int())
self.assertEqual(3, self.dicom.metadata.count())
def test_filter_has_bugs(self):
"""test filter with a broken filter function"""
with self.assertRaisesRegexp(Exception, "this filter is broken!"):
self.dicom.filter(self._filter_has_bugs())
self.dicom.metadata.count()
def test_filter_invalid_param(self):
"""test filter with an invalid param type"""
# should fail because filter takes a function not a keyvalue pair
with self.assertRaisesRegexp(Exception, "'dict' object is not callable"):
self.dicom.filter({ "PatientID" : "bla" })
self.dicom.metadata.count()
def test_filter_invalid_function(self):
"""test filter with function which takes more than one param"""
with self.assertRaisesRegexp(Exception, "takes exactly 2 arguments"):
self.dicom.filter(self._filter_invalid())
self.dicom.metadata.count()
def _filter_key_values(self, key_val):
"""filter by key-value"""
def _filter_key_value(row):
metadata = row["metadata"].encode("ascii", "ignore")
xml_root = etree.fromstring(metadata)
for key in key_val:
xml_element_value = xml_root.xpath(".//DicomAttribute[@keyword='" + key + "']/Value/text()")[0]
if xml_element_value != key_val[key]:
return False
else:
return True
return _filter_key_value
def _filter_nothing(self):
"""returns all records"""
def _filter_nothing(row):
return True
return _filter_nothing
def _filter_everything(self):
"""returns no records"""
def _filter_everything(row):
return False
return _filter_everything
def _filter_timestamp_range(self, begin_date, end_date):
"""return records within studydate date range"""
def _filter_timestamp_range(row):
metadata = row["metadata"].encode("ascii", "ignore")
xml_root = etree.fromstring(metadata)
timestamp = xml_root.xpath(".//DicomAttribute[@keyword='StudyDate']/Value/text()")[0]
timestamp = datetime.datetime.strptime(timestamp, "%Y%m%d")
if begin_date < timestamp and timestamp < end_date:
return True
else:
return False
return _filter_timestamp_range
def _filter_return_string(self):
"""filter function which returns str"""
def _filter_return_string(row):
return "True"
return _filter_return_string
def _filter_return_int(self):
"""filter function returns int"""
def _filter_return_int(row):
return -1
return _filter_return_int
def _filter_has_bugs(self):
"""broken filter function"""
def _filter_has_bugs(row):
raise Exception("this filter is broken!")
return _filter_has_bugs
def _filter_invalid(self):
"""filter function takes 2 params"""
# filter is invalid because it takes
# 2 parameters
def _filter_invalid(index, row):
return True
return _filter_invalid
def _filter(self, keywords):
"""filter records by key value pair"""
# here we are generating the expected result
matching_records = []
pandas_metadata = self.dicom.metadata.to_pandas()["metadata"]
for row in pandas_metadata:
ascii_xml = row.encode("ascii", "ignore")
xml = etree.fromstring(row.encode("ascii", "ignore"))
for keyword in keywords:
this_row_keyword_value = xml.xpath(self.query.replace("KEYWORD", keyword))
if this_row_keyword_value == keyword:
matching_records.append(ascii_xml)
return matching_records
def _compare_dicom_with_expected_result(self, expected_result):
"""compare expected result with actual result"""
pandas_result = self.dicom.metadata.to_pandas()["metadata"]
for expected, actual in zip(expected_result, pandas_result):
actual_ascii = actual.encode("ascii", "ignore")
self.assertEqual(actual_ascii, expected)
if __name__ == "__main__":
unittest.main()
| apache-2.0 |
ocefpaf/iris | docs/iris/src/sphinxext/gen_gallery.py | 2 | 6174 | #
# (C) Copyright 2012 MATPLOTLIB (vn 1.2.0)
#
'''
Generate a thumbnail gallery of examples.
'''
import os
import glob
import re
import warnings
import matplotlib.image as image
from sphinx.util import status_iterator
from sphinx.util import status_iterator
template = '''\
{{% extends "layout.html" %}}
{{% set title = "Thumbnail gallery" %}}
{{% block body %}}
<h3>Click on any image to see full size image and source code</h3>
<br/>
<ul>
<li><a class="reference internal" href="#">Gallery</a>
<ul>
{}
</ul>
</li>
</ul>
{}
{{% endblock %}}
'''
multiimage = re.compile('(.*?)(_\d\d){1,2}')
def make_thumbnail(args):
image.thumbnail(args[0], args[1], 0.4)
def out_of_date(original, derived):
return (not os.path.exists(derived) or
os.stat(derived).st_mtime < os.stat(original).st_mtime)
def gen_gallery(app, doctree):
if app.builder.name != 'html':
return
outdir = app.builder.outdir
rootdir = 'examples'
# Images we want to skip for the gallery because they are an unusual
# size that doesn't layout well in a table, or because they may be
# redundant with other images or uninteresting.
skips = set([
'mathtext_examples',
'matshow_02',
'matshow_03',
'matplotlib_icon'])
thumbnails = {}
rows = []
random_image = []
toc_rows = []
link_template = ('<a href="{href}">'
'<img src="{thumb_file}" border="0"'
' alt="{alternative_text}"/>'
'</a>')
header_template = ('<div class="section" id="{}">'
'<h4>{}'
'<a class="headerlink" href="#{}"'
' title="Permalink to this headline">¶</a>'
'</h4>')
toc_template = ('<li>'
'<a class="reference internal" href="#{}">{}</a>'
'</li>')
random_image_content_template = '''
// This file was automatically generated by gen_gallery.py & should not be
// modified directly.
images = new Array();
{}
'''
random_image_template = "['{thumbfile}', '{full_image}', '{link}'];"
random_image_join = 'images[{}] = {}'
dirs = ('General', 'Meteorology', 'Oceanography')
for subdir in dirs:
rows.append(header_template.format(subdir, subdir, subdir))
toc_rows.append(toc_template.format(subdir, subdir))
origdir = os.path.join(os.path.dirname(outdir), rootdir, subdir)
if not os.path.exists(origdir):
origdir = os.path.join(os.path.dirname(outdir), 'plot_directive',
rootdir, subdir)
thumbdir = os.path.join(outdir, rootdir, subdir, 'thumbnails')
if not os.path.exists(thumbdir):
os.makedirs(thumbdir)
data = []
for filename in sorted(glob.glob(os.path.join(origdir, '*.png'))):
if filename.endswith('hires.png'):
continue
path, filename = os.path.split(filename)
basename, ext = os.path.splitext(filename)
if basename in skips:
continue
# Create thumbnails based on images in tmpdir, and place them
# within the build tree.
orig_path = str(os.path.join(origdir, filename))
thumb_path = str(os.path.join(thumbdir, filename))
if out_of_date(orig_path, thumb_path) or True:
thumbnails[orig_path] = thumb_path
m = multiimage.match(basename)
if m is not None:
basename = m.group(1)
data.append((subdir, basename,
os.path.join(rootdir, subdir, 'thumbnails',
filename)))
for (subdir, basename, thumbfile) in data:
if thumbfile is not None:
anchor = os.path.basename(thumbfile)
anchor = os.path.splitext(anchor)[0].replace('_', '-')
link = 'examples/{}/{}.html#{}'.format(
subdir,
basename,
anchor)
rows.append(link_template.format(
href=link,
thumb_file=thumbfile,
alternative_text=basename))
random_image.append(random_image_template.format(
link=link,
thumbfile=thumbfile,
basename=basename,
full_image='_images/' + os.path.basename(thumbfile)))
if len(data) == 0:
warnings.warn('No thumbnails were found in {}'.format(subdir))
# Close out the <div> opened up at the top of this loop.
rows.append('</div>')
# Generate JS list of images for front page.
random_image_content = '\n'.join([random_image_join.format(i, line)
for i, line in enumerate(random_image)])
random_image_content = random_image_content_template.format(
random_image_content)
random_image_script_path = os.path.join(app.builder.srcdir,
'_static',
'random_image.js')
with open(random_image_script_path, 'w') as fh:
fh.write(random_image_content)
content = template.format('\n'.join(toc_rows),
'\n'.join(rows))
# Only write out the file if the contents have actually changed.
# Otherwise, this triggers a full rebuild of the docs.
gallery_path = os.path.join(app.builder.srcdir,
'_templates',
'gallery.html')
if os.path.exists(gallery_path):
with open(gallery_path, 'r') as fh:
regenerate = fh.read() != content
else:
regenerate = True
if regenerate:
with open(gallery_path, 'w') as fh:
fh.write(content)
for key in status_iterator(thumbnails, 'generating thumbnails... ',
length=len(thumbnails)):
image.thumbnail(key, thumbnails[key], 0.3)
def setup(app):
app.connect('env-updated', gen_gallery)
| lgpl-3.0 |
jmetzen/scikit-learn | examples/model_selection/plot_validation_curve.py | 141 | 1931 | """
==========================
Plotting Validation Curves
==========================
In this plot you can see the training scores and validation scores of an SVM
for different values of the kernel parameter gamma. For very low values of
gamma, you can see that both the training score and the validation score are
low. This is called underfitting. Medium values of gamma will result in high
values for both scores, i.e. the classifier is performing fairly well. If gamma
is too high, the classifier will overfit, which means that the training score
is good but the validation score is poor.
"""
print(__doc__)
import matplotlib.pyplot as plt
import numpy as np
from sklearn.datasets import load_digits
from sklearn.svm import SVC
from sklearn.model_selection import validation_curve
digits = load_digits()
X, y = digits.data, digits.target
param_range = np.logspace(-6, -1, 5)
train_scores, test_scores = validation_curve(
SVC(), X, y, param_name="gamma", param_range=param_range,
cv=10, scoring="accuracy", n_jobs=1)
train_scores_mean = np.mean(train_scores, axis=1)
train_scores_std = np.std(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)
plt.title("Validation Curve with SVM")
plt.xlabel("$\gamma$")
plt.ylabel("Score")
plt.ylim(0.0, 1.1)
lw = 2
plt.semilogx(param_range, train_scores_mean, label="Training score",
color="darkorange", lw=lw)
plt.fill_between(param_range, train_scores_mean - train_scores_std,
train_scores_mean + train_scores_std, alpha=0.2,
color="darkorange", lw=lw)
plt.semilogx(param_range, test_scores_mean, label="Cross-validation score",
color="navy", lw=lw)
plt.fill_between(param_range, test_scores_mean - test_scores_std,
test_scores_mean + test_scores_std, alpha=0.2,
color="navy", lw=lw)
plt.legend(loc="best")
plt.show()
| bsd-3-clause |
anamariad/ML | Clusterization/clusterization/utils.py | 1 | 1884 | __author__ = 'Annouk'
import os
import numpy as np
import matplotlib.pyplot as plt
def read_points(csv_file_name):
points = np.loadtxt(csv_file_name, delimiter = ',')
return points
def plot_clusters(centroids, clusters):
# we assume centroids is a list of points and clusters is a dictionary of arrays
# we transpose them, so we could get 2 different arrays, representing the X and Y coordinates
clusters_no = len(centroids)
centroids_transposed = np.array(centroids).T
x_centroids = centroids_transposed[0]
y_centroids = centroids_transposed[1]
for i in range(clusters_no):
cluster = np.array(clusters[i]).transpose()
x_cluster = cluster[0]
y_cluster = cluster[1]
# setting a different color for each cluster
plt.scatter(x_cluster, y_cluster, c = np.random.rand(1, 3))
plt.scatter(x_centroids, y_centroids, c = 'r')
plt.show()
def plot_clusters_1d(centroids, clusters):
# adapting the above function to work with one dimensional data
clusters_no = len(clusters)
x_centroids = np.array(centroids)
y_centroids = np.zeros(clusters_no)
for i in range(clusters_no):
x_cluster = np.array(clusters[i])
y_cluster = np.zeros(len(clusters[i]))
# setting a different color for each cluster
plt.scatter(x_cluster, y_cluster, c = np.random.rand(1, 3))
plt.scatter(x_centroids, y_centroids, c = 'r')
plt.show()
def convergence(centroids, oldcentroids, threshold):
return np.linalg.norm(centroids - oldcentroids) < threshold
def print_matrix_to_file(matrix, output_file):
for i in range(len(matrix)):
output_file.write(','.join(str(nr) for nr in matrix[i]))
output_file.write('\n')
def print_array_to_file(array, output_file):
output_file.write(','.join(str(nr) for nr in array))
output_file.write('\n') | apache-2.0 |
plowman/python-mcparseface | models/autoencoder/MaskingNoiseAutoencoderRunner.py | 10 | 1689 | import numpy as np
import sklearn.preprocessing as prep
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
from autoencoder.autoencoder_models.DenoisingAutoencoder import MaskingNoiseAutoencoder
mnist = input_data.read_data_sets('MNIST_data', one_hot = True)
def standard_scale(X_train, X_test):
preprocessor = prep.StandardScaler().fit(X_train)
X_train = preprocessor.transform(X_train)
X_test = preprocessor.transform(X_test)
return X_train, X_test
def get_random_block_from_data(data, batch_size):
start_index = np.random.randint(0, len(data) - batch_size)
return data[start_index:(start_index + batch_size)]
X_train, X_test = standard_scale(mnist.train.images, mnist.test.images)
n_samples = int(mnist.train.num_examples)
training_epochs = 100
batch_size = 128
display_step = 1
autoencoder = MaskingNoiseAutoencoder(n_input = 784,
n_hidden = 200,
transfer_function = tf.nn.softplus,
optimizer = tf.train.AdamOptimizer(learning_rate = 0.001),
dropout_probability = 0.95)
for epoch in range(training_epochs):
avg_cost = 0.
total_batch = int(n_samples / batch_size)
for i in range(total_batch):
batch_xs = get_random_block_from_data(X_train, batch_size)
cost = autoencoder.partial_fit(batch_xs)
avg_cost += cost / n_samples * batch_size
if epoch % display_step == 0:
print "Epoch:", '%04d' % (epoch + 1), \
"cost=", "{:.9f}".format(avg_cost)
print "Total cost: " + str(autoencoder.calc_total_cost(X_test))
| apache-2.0 |
mne-tools/mne-python | mne/io/array/tests/test_array.py | 4 | 6460 | # Author: Eric Larson <[email protected]>
#
# License: BSD (3-clause)
import os.path as op
import numpy as np
from numpy.testing import (assert_array_almost_equal, assert_allclose,
assert_equal)
import pytest
import matplotlib.pyplot as plt
from mne import find_events, Epochs, pick_types
from mne.io import read_raw_fif
from mne.io.array import RawArray
from mne.io.tests.test_raw import _test_raw_reader
from mne.io.meas_info import create_info
from mne.io.pick import get_channel_type_constants
from mne.channels import make_dig_montage
base_dir = op.join(op.dirname(__file__), '..', '..', 'tests', 'data')
fif_fname = op.join(base_dir, 'test_raw.fif')
def test_long_names():
"""Test long name support."""
info = create_info(['a' * 15 + 'b', 'a' * 16], 1000., verbose='error')
data = np.empty((2, 1000))
raw = RawArray(data, info)
assert raw.ch_names == ['a' * 15 + 'b', 'a' * 16]
# and a way to get the old behavior
raw.rename_channels({k: k[:13] for k in raw.ch_names},
allow_duplicates=True, verbose='error')
assert raw.ch_names == ['a' * 13 + '-0', 'a' * 13 + '-1']
info = create_info(['a' * 16] * 11, 1000., verbose='error')
data = np.empty((11, 1000))
raw = RawArray(data, info)
assert raw.ch_names == ['a' * 16 + '-%s' % ii for ii in range(11)]
def test_array_copy():
"""Test copying during construction."""
info = create_info(1, 1000.)
data = np.empty((1, 1000))
# 'auto' (default)
raw = RawArray(data, info)
assert raw._data is data
assert raw.info is not info
raw = RawArray(data.astype(np.float32), info)
assert raw._data is not data
assert raw.info is not info
# 'info' (more restrictive)
raw = RawArray(data, info, copy='info')
assert raw._data is data
assert raw.info is not info
with pytest.raises(ValueError, match="data copying was not .* copy='info"):
RawArray(data.astype(np.float32), info, copy='info')
# 'data'
raw = RawArray(data, info, copy='data')
assert raw._data is not data
assert raw.info is info
# 'both'
raw = RawArray(data, info, copy='both')
assert raw._data is not data
assert raw.info is not info
raw = RawArray(data.astype(np.float32), info, copy='both')
assert raw._data is not data
assert raw.info is not info
# None
raw = RawArray(data, info, copy=None)
assert raw._data is data
assert raw.info is info
with pytest.raises(ValueError, match='data copying was not .* copy=None'):
RawArray(data.astype(np.float32), info, copy=None)
@pytest.mark.slowtest
def test_array_raw():
"""Test creating raw from array."""
# creating
raw = read_raw_fif(fif_fname).crop(2, 5)
data, times = raw[:, :]
sfreq = raw.info['sfreq']
ch_names = [(ch[4:] if 'STI' not in ch else ch)
for ch in raw.info['ch_names']] # change them, why not
types = list()
for ci in range(101):
types.extend(('grad', 'grad', 'mag'))
types.extend(['ecog', 'seeg', 'hbo']) # really 4 meg channels
types.extend(['stim'] * 9)
types.extend(['dbs']) # really eeg channel
types.extend(['eeg'] * 60)
picks = np.concatenate([pick_types(raw.info, meg=True)[::20],
pick_types(raw.info, meg=False, stim=True),
pick_types(raw.info, meg=False, eeg=True)[::20]])
del raw
data = data[picks]
ch_names = np.array(ch_names)[picks].tolist()
types = np.array(types)[picks].tolist()
types.pop(-1)
# wrong length
pytest.raises(ValueError, create_info, ch_names, sfreq, types)
# bad entry
types.append('foo')
pytest.raises(KeyError, create_info, ch_names, sfreq, types)
types[-1] = 'eog'
# default type
info = create_info(ch_names, sfreq)
assert_equal(info['chs'][0]['kind'],
get_channel_type_constants()['misc']['kind'])
# use real types
info = create_info(ch_names, sfreq, types)
raw2 = _test_raw_reader(RawArray, test_preloading=False,
data=data, info=info, first_samp=2 * data.shape[1])
data2, times2 = raw2[:, :]
assert_allclose(data, data2)
assert_allclose(times, times2)
assert ('RawArray' in repr(raw2))
pytest.raises(TypeError, RawArray, info, data)
# filtering
picks = pick_types(raw2.info, meg=True, misc=True, exclude='bads')[:4]
assert_equal(len(picks), 4)
raw_lp = raw2.copy()
kwargs = dict(fir_design='firwin', picks=picks)
raw_lp.filter(None, 4.0, h_trans_bandwidth=4., **kwargs)
raw_hp = raw2.copy()
raw_hp.filter(16.0, None, l_trans_bandwidth=4., **kwargs)
raw_bp = raw2.copy()
raw_bp.filter(8.0, 12.0, l_trans_bandwidth=4., h_trans_bandwidth=4.,
**kwargs)
raw_bs = raw2.copy()
raw_bs.filter(16.0, 4.0, l_trans_bandwidth=4., h_trans_bandwidth=4.,
**kwargs)
data, _ = raw2[picks, :]
lp_data, _ = raw_lp[picks, :]
hp_data, _ = raw_hp[picks, :]
bp_data, _ = raw_bp[picks, :]
bs_data, _ = raw_bs[picks, :]
sig_dec = 15
assert_array_almost_equal(data, lp_data + bp_data + hp_data, sig_dec)
assert_array_almost_equal(data, bp_data + bs_data, sig_dec)
# plotting
raw2.plot()
raw2.plot_psd(tmax=2., average=True, n_fft=1024,
spatial_colors=False)
plt.close('all')
# epoching
events = find_events(raw2, stim_channel='STI 014')
events[:, 2] = 1
assert len(events) > 2
epochs = Epochs(raw2, events, 1, -0.2, 0.4, preload=True)
evoked = epochs.average()
assert_equal(evoked.nave, len(events) - 1)
# complex data
rng = np.random.RandomState(0)
data = rng.randn(1, 100) + 1j * rng.randn(1, 100)
raw = RawArray(data, create_info(1, 1000., 'eeg'))
assert_allclose(raw._data, data)
# Using digital montage to give MNI electrode coordinates
n_elec = 10
ts_size = 10000
Fs = 512.
ch_names = [str(i) for i in range(n_elec)]
ch_pos_loc = np.random.randint(60, size=(n_elec, 3)).tolist()
data = np.random.rand(n_elec, ts_size)
montage = make_dig_montage(
ch_pos=dict(zip(ch_names, ch_pos_loc)),
coord_frame='head'
)
info = create_info(ch_names, Fs, 'ecog')
raw = RawArray(data, info)
raw.set_montage(montage)
raw.plot_psd(average=False) # looking for nonexistent layout
raw.plot_psd_topo()
| bsd-3-clause |
bthirion/scikit-learn | examples/calibration/plot_calibration_multiclass.py | 95 | 6971 | """
==================================================
Probability Calibration for 3-class classification
==================================================
This example illustrates how sigmoid calibration changes predicted
probabilities for a 3-class classification problem. Illustrated is the
standard 2-simplex, where the three corners correspond to the three classes.
Arrows point from the probability vectors predicted by an uncalibrated
classifier to the probability vectors predicted by the same classifier after
sigmoid calibration on a hold-out validation set. Colors indicate the true
class of an instance (red: class 1, green: class 2, blue: class 3).
The base classifier is a random forest classifier with 25 base estimators
(trees). If this classifier is trained on all 800 training datapoints, it is
overly confident in its predictions and thus incurs a large log-loss.
Calibrating an identical classifier, which was trained on 600 datapoints, with
method='sigmoid' on the remaining 200 datapoints reduces the confidence of the
predictions, i.e., moves the probability vectors from the edges of the simplex
towards the center. This calibration results in a lower log-loss. Note that an
alternative would have been to increase the number of base estimators which
would have resulted in a similar decrease in log-loss.
"""
print(__doc__)
# Author: Jan Hendrik Metzen <[email protected]>
# License: BSD Style.
import matplotlib.pyplot as plt
import numpy as np
from sklearn.datasets import make_blobs
from sklearn.ensemble import RandomForestClassifier
from sklearn.calibration import CalibratedClassifierCV
from sklearn.metrics import log_loss
np.random.seed(0)
# Generate data
X, y = make_blobs(n_samples=1000, n_features=2, random_state=42,
cluster_std=5.0)
X_train, y_train = X[:600], y[:600]
X_valid, y_valid = X[600:800], y[600:800]
X_train_valid, y_train_valid = X[:800], y[:800]
X_test, y_test = X[800:], y[800:]
# Train uncalibrated random forest classifier on whole train and validation
# data and evaluate on test data
clf = RandomForestClassifier(n_estimators=25)
clf.fit(X_train_valid, y_train_valid)
clf_probs = clf.predict_proba(X_test)
score = log_loss(y_test, clf_probs)
# Train random forest classifier, calibrate on validation data and evaluate
# on test data
clf = RandomForestClassifier(n_estimators=25)
clf.fit(X_train, y_train)
clf_probs = clf.predict_proba(X_test)
sig_clf = CalibratedClassifierCV(clf, method="sigmoid", cv="prefit")
sig_clf.fit(X_valid, y_valid)
sig_clf_probs = sig_clf.predict_proba(X_test)
sig_score = log_loss(y_test, sig_clf_probs)
# Plot changes in predicted probabilities via arrows
plt.figure(0)
colors = ["r", "g", "b"]
for i in range(clf_probs.shape[0]):
plt.arrow(clf_probs[i, 0], clf_probs[i, 1],
sig_clf_probs[i, 0] - clf_probs[i, 0],
sig_clf_probs[i, 1] - clf_probs[i, 1],
color=colors[y_test[i]], head_width=1e-2)
# Plot perfect predictions
plt.plot([1.0], [0.0], 'ro', ms=20, label="Class 1")
plt.plot([0.0], [1.0], 'go', ms=20, label="Class 2")
plt.plot([0.0], [0.0], 'bo', ms=20, label="Class 3")
# Plot boundaries of unit simplex
plt.plot([0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], 'k', label="Simplex")
# Annotate points on the simplex
plt.annotate(r'($\frac{1}{3}$, $\frac{1}{3}$, $\frac{1}{3}$)',
xy=(1.0/3, 1.0/3), xytext=(1.0/3, .23), xycoords='data',
arrowprops=dict(facecolor='black', shrink=0.05),
horizontalalignment='center', verticalalignment='center')
plt.plot([1.0/3], [1.0/3], 'ko', ms=5)
plt.annotate(r'($\frac{1}{2}$, $0$, $\frac{1}{2}$)',
xy=(.5, .0), xytext=(.5, .1), xycoords='data',
arrowprops=dict(facecolor='black', shrink=0.05),
horizontalalignment='center', verticalalignment='center')
plt.annotate(r'($0$, $\frac{1}{2}$, $\frac{1}{2}$)',
xy=(.0, .5), xytext=(.1, .5), xycoords='data',
arrowprops=dict(facecolor='black', shrink=0.05),
horizontalalignment='center', verticalalignment='center')
plt.annotate(r'($\frac{1}{2}$, $\frac{1}{2}$, $0$)',
xy=(.5, .5), xytext=(.6, .6), xycoords='data',
arrowprops=dict(facecolor='black', shrink=0.05),
horizontalalignment='center', verticalalignment='center')
plt.annotate(r'($0$, $0$, $1$)',
xy=(0, 0), xytext=(.1, .1), xycoords='data',
arrowprops=dict(facecolor='black', shrink=0.05),
horizontalalignment='center', verticalalignment='center')
plt.annotate(r'($1$, $0$, $0$)',
xy=(1, 0), xytext=(1, .1), xycoords='data',
arrowprops=dict(facecolor='black', shrink=0.05),
horizontalalignment='center', verticalalignment='center')
plt.annotate(r'($0$, $1$, $0$)',
xy=(0, 1), xytext=(.1, 1), xycoords='data',
arrowprops=dict(facecolor='black', shrink=0.05),
horizontalalignment='center', verticalalignment='center')
# Add grid
plt.grid("off")
for x in [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]:
plt.plot([0, x], [x, 0], 'k', alpha=0.2)
plt.plot([0, 0 + (1-x)/2], [x, x + (1-x)/2], 'k', alpha=0.2)
plt.plot([x, x + (1-x)/2], [0, 0 + (1-x)/2], 'k', alpha=0.2)
plt.title("Change of predicted probabilities after sigmoid calibration")
plt.xlabel("Probability class 1")
plt.ylabel("Probability class 2")
plt.xlim(-0.05, 1.05)
plt.ylim(-0.05, 1.05)
plt.legend(loc="best")
print("Log-loss of")
print(" * uncalibrated classifier trained on 800 datapoints: %.3f "
% score)
print(" * classifier trained on 600 datapoints and calibrated on "
"200 datapoint: %.3f" % sig_score)
# Illustrate calibrator
plt.figure(1)
# generate grid over 2-simplex
p1d = np.linspace(0, 1, 20)
p0, p1 = np.meshgrid(p1d, p1d)
p2 = 1 - p0 - p1
p = np.c_[p0.ravel(), p1.ravel(), p2.ravel()]
p = p[p[:, 2] >= 0]
calibrated_classifier = sig_clf.calibrated_classifiers_[0]
prediction = np.vstack([calibrator.predict(this_p)
for calibrator, this_p in
zip(calibrated_classifier.calibrators_, p.T)]).T
prediction /= prediction.sum(axis=1)[:, None]
# Plot modifications of calibrator
for i in range(prediction.shape[0]):
plt.arrow(p[i, 0], p[i, 1],
prediction[i, 0] - p[i, 0], prediction[i, 1] - p[i, 1],
head_width=1e-2, color=colors[np.argmax(p[i])])
# Plot boundaries of unit simplex
plt.plot([0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], 'k', label="Simplex")
plt.grid("off")
for x in [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]:
plt.plot([0, x], [x, 0], 'k', alpha=0.2)
plt.plot([0, 0 + (1-x)/2], [x, x + (1-x)/2], 'k', alpha=0.2)
plt.plot([x, x + (1-x)/2], [0, 0 + (1-x)/2], 'k', alpha=0.2)
plt.title("Illustration of sigmoid calibrator")
plt.xlabel("Probability class 1")
plt.ylabel("Probability class 2")
plt.xlim(-0.05, 1.05)
plt.ylim(-0.05, 1.05)
plt.show()
| bsd-3-clause |
astronomeara/xastropy-old | xastropy/phot/ian_phot.py | 7 | 46065 | """Python script for various photometry tasks. See especially
:func:`aperphot`, for basic aperture photometry. If you need
something fancier, try PyRAF, DAOPHOT, etc.
"""
# 2008-12-21 18:27 IJC: Created
from numpy import array, sign, pi, nan, arange
import numpy as np
import pdb
#try:
# import psyco
# psyco.full()
#except ImportError:
# print 'Psyco not installed, the program will just run slower'
class phot:
def __init__(self, **kw):
"""Generate a photometry object w/keywords and kw+'str' descriptive keywords
Inputs cannot be numpy arrays"""
# 2009-09-14 10:07 IJC: Created
keylist = ['time', 'phot', 'ephot', 'bg', 'ebg', 'aper', 'position', 'eposition', \
'ditherposition', 'object', 'filename', 'exptime', 'ra', 'dec']
defaults = dict(photunit=None)
for key in keylist:
defaults[key]=None
defaults[key+'str']=None
keylist = keylist + [key+'str']
for keyword in defaults:
if (not kw.has_key(keyword)):
kw[keyword] = defaults[keyword]
for k in kw.keys():
if kw[k].__class__==str:
exec('self.'+k+'="'+str(kw[k]))+'"'
else:
exec('self.'+k+'='+str(kw[k]))
self.comment = "Created by IJC's spitzer.phot"
return
def __str__(self): # Return info
lin= 'Phot: {} at pixel ({:.1f},{:.1f})\n'.format(self.object,
self.position[0],
self.position[1])
lin+= ' Analyzed frame {}\n'.format(self.filename)
lin+= ' Exposure time = {:.1f}s\n'.format(self.exptime)
lin+= ' Aperture = {}, {}, {}\n'.format(self.aper[0],
self.aper[1],self.aper[2])
#lin+= ' {}\n'.format(self.aperstr)
lin+= ' Counts/s = {} +/- {}\n'.format(self.phot,self.ephot)
return lin
def estbg(im, mask=None, bins=None, plotalot=False, rout=(3,200), badval=nan):
"""Estimate the background value of a masked image via histogram fitting.
INPUTS:
im -- numpy array. Input image.
OPTIONAL INPUTS:
mask -- numpy array. logical mask, False/0 in regions to ignore
bins -- sequence. edges of bins to pass to HIST
plotalot -- bool. Plot the histogram and fit.
rout -- 2-tuple of (nsigma, niter) for analysis.removeoutliers.
Set to (Inf, 0) to not cut any outliers.
badval -- value returned when things go wrong.
OUTPUT:
b, s_b -- tuple of (background, error on background) from gaussian fit.
Note that the error is analagous to the standard deviation on the mean
COMMENTS:
The fit parameters appear to be robust across a fairly wide range of bin sizes. """
# 2009-09-02 17:13 IJC: Created!
# 2009-09-04 15:07 IJC: Added RemoveOutliers option. Use only non-empty bins in fit.
# 2009-09-08 15:32 IJC: Error returned is now divided by sqrt(N) for SDOM
# 2009-11-03 00:16 IJC: Improved guess for gaussian dispersion
# 2011-05-18 11:47 IJMC: Moved (e)gaussian imports to analysis.
# 2012-01-01 21:04 IJMC: Added badval option
# 2012-08-15 17:45 IJMC: Numpy's new histogram no longer accepts 'new' keyword
# 2013-03-20 08:22 IJMC: Now works better even for small numbers
# of pixels; thanks to A. Weigel @
# ETH-Zurich for catching this!
from numpy import histogram, mean, median, sqrt, linspace, isfinite, ones,std
from pylab import find
from scipy import optimize
from xastropy.phot.ian_analysis import removeoutliers, egaussian, gaussian, stdr
if plotalot:
from pylab import figure, errorbar, plot, colorbar, title, hist, mean, std
#from analysis import imshow
def gaussianChiSquared(guess, x, y, err):
return (egaussian(guess, x, y, e=err)**2).sum()
if mask==None:
mask = ones(im.shape)
dat = im.ravel()[find(mask<>0)]
if plotalot:
figure(); plot(im.ravel()); plot(dat)
print mean(dat), std(dat), rout[0]*std(dat)
print len(dat), (abs(dat-mean(dat))<(rout[0]*std(dat))).sum()
figure(); plot(dat-mean(dat));
plot([0,len(dat)], [rout[0]*std(dat),rout[0]*std(dat)],'--k')
plot([0,len(dat)], [-rout[0]*std(dat),-rout[0]*std(dat)],'--k')
dat = removeoutliers(dat, rout[0], remove='both', center='mean', niter=rout[1], verbose=plotalot)
ndat = len(dat)
if ndat==0:
print "No data to work with!"
return (badval, badval)
if bins==None:
if plotalot: print "no bins entered!"
datmean = dat.mean()
datstd = stdr(dat, nsigma=3)
nunique = len(np.unique(dat.ravel()))
#pdb.set_trace()
if nunique > len(dat)/20.:
dobin = False
else:
dobin = True
bins = linspace(dat.min(), dat.max(), nunique/2)
if plotalot:
print "dat.mean, dat.std>>" + str((dat.mean(), dat.std()))
#if plotalot:
# figure(); hout = hist(dat[datIndex],bins)
#else:
if dobin:
binwidth = mean(bins[1::]-bins[:-1])
bincenter = 0.5*(bins[1::]+bins[:-1])
datIndex = (dat>=bins.min()) * (dat<=bins.max())
hout = histogram(dat[datIndex], bins) #,new=True)
gy = hout[0]
erry = sqrt(gy)
usableIndex = gy>0
eff_binwidth = mean(bins[usableIndex][1::]-bins[usableIndex][:-1])
guess = [gy.sum()*eff_binwidth, std(dat[datIndex]), median(dat[datIndex])]
if 1.0*usableIndex.sum()/usableIndex.size < 0.5:
out = guess
else:
out = optimize.fmin(gaussianChiSquared, guess, \
args=(bincenter[usableIndex],gy[usableIndex], erry[usableIndex]), \
disp=plotalot)
if plotalot:
from pylab import figure, errorbar, plot, colorbar, title
from nsdata import imshow
print 'guess>>',guess
print 'fit>>',out
figure()
imshow(im); colorbar()
figure()
errorbar(bincenter[usableIndex], gy[usableIndex], erry[usableIndex], fmt='ob')
plot(bincenter, gaussian(out, bincenter),'-r', linewidth=2)
title('Mean: %f, Std. Dev.: %f' % (out[2], out[1]))
ret = out[2], out[1]/sqrt(ndat)
else:
ret = datmean, datstd/sqrt(ndat)
return ret
def makemask(x,y,params, shape='circle'):
"""Generate a binary (logical) mask with given shape and location.
INPUTS:
x = x-coodinate system (made with meshgrid)
y = y-coodinate system (made with meshgrid)
params:
shape='circle':
params(1) = x-offset
params(2) = y-offset
params(3) = x-diameter
params(4) = OPTIONAL y-diameter
shape='quad':
params: list of quadrants to include in the mask. The
midpoint for determining quadrants will be
mid = (xmax+xmin)/2. Quadrants are:
0: x<midX and y<midY
1: x<midX and y>=midY
2: x>=midX and y<midY
3: x>=midX and y>=midY
OPTIONAL INPUTS:
shape=: desired mask shape. Currently only 'circle' is valid.
OUTPUTS:
mask = NxM grided representation of specified mask
where NxM are the size of the x,y input meshgrids
EXAMPLE:
x=arange(32); y=arange(64)
xx,yy = meshgrid(x,y)
m = makemask(xx,yy,(24, 53, 10))
m[53,24] # ----> True
"""
# 2009-09-02 10:47 IJC: Created. Adapted from Joe Green's MakeEllipse.m
# 2009-09-27 13:37 IJC: Added 'quad' quadrant mask option.
from numpy import zeros, bool
if not x.shape==y.shape:
print "x,y meshgrid coordinates must be the same shape! Exiting."
return -1
if shape=='circle':
if len(params)<3:
print "Must give at least 3 parameters to mask."
return -1
x0 = params[0]
y0 = params[1]
xdia =params[2]
if len(params)==3:
ydia = xdia
else:
ydia = params[3]
mask = ( (((x-x0)/(xdia/2.))**2 + ((y-y0)/(ydia/2.))**2) < 1 )
elif shape=='quad':
midx = (x.max()+x.min())/2.
midy = (y.max()+y.min())/2.
mask = zeros(x.shape, bool)
for ii in range(len(params)):
if params[ii]==0:
mask += (x<midx) * (y<midy)
elif params[ii]==1:
mask += (x<midx) * (y>=midy)
elif params[ii]==2:
mask += (x>=midx) * (y<midy)
elif params[ii]==3:
mask += (x>=midx) * (y>=midy)
return mask
def centroid(im, mask=None, w=None, x=None, y=None):
"""Compute the centroid of an image with a specified binary mask projected upon it.
INPUT:
im -- image array
mask -- binary mask, 0 in ignored regions and 1 in desired regions
w is typically 1.0/u**2, where u is the uncertainty on im
x,y are those generated by meshgrid.
OUTPUT:
(x0,y0) tuple of centroid location"""
from numpy import ones, arange, meshgrid
# 2009-09-02 13:35 IJC: Created
if mask==None:
mask = ones(im.shape)
if w==None:
w = ones(im.shape)
if not (im.shape==mask.shape and im.shape==w.shape):
print "Image, mask, and weights must have same shape! Exiting."
return -1
if x==None or y==None:
xx = arange(im.shape[1])
yy = arange(im.shape[0])
x,y = meshgrid(xx,yy)
x0 = (x*im*mask*w).sum()/(im*mask*w).sum()
y0 = (y*im*mask*w).sum()/(im*mask*w).sum()
return (x0,y0)
def lmcextinct(ra, dec, **kw):
"""Use the Zaritsky & Harris (ZH) map to get A_V extinction in the LMC.
INPUT:
ra -- decimal degrees of right ascension
dec -- decimal degrees of declination
OPTIONAL INPUT:
method='griddata' /'nearest' -- interpolation method
map='both' /'hot'/'cool' -- Which ZH map to use
hot='lmc_hotav.fits' -- filename of hot map
cool='lmc_coolav.fits' -- filename of cool map
null=0.0 -- "no data" value in map
verbose=False / True -- print out some spam and eggs
EXAMPLE:
ra = hms('05:51:56.6')
dec = dms('-66:25:08.5')
lmcextinct(ra, dec)
If their map returns null, interpolate from the surroundings.
Note that these calculations are definitely _not_ optimized.
SEE ALSO:
hms, dms"""
# 2009-02-15 22:11 IJC: Created and tested.
import astropy.io.fits as pyfits
from matplotlib.mlab import griddata
from pylab import meshgrid, arange, array, sqrt, cos, sin, arctan2, arcsin
ra = array([ra]).copy().ravel()
dec = array([dec]).copy().ravel()
defaults = dict(method='griddata', map='hot', hot='lmc_hotav_clean2.fits',
cool='lmc_coolav.fits', null=0.0, verbose=False)
for key in defaults:
if (not kw.has_key(key)):
kw[key] = defaults[key]
if kw['map']=='both':
kw['map'] = 'hot'
ret1 = lmcextinct(ra, dec, **kw)
kw['map'] = 'cool'
ret2 = lmcextinct(ra, dec, **kw)
return (ret1, ret2)
else:
map = kw[kw['map']]
verbose = kw['verbose']
avmap = pyfits.getdata(map)
avhdr = pyfits.getheader(map)
nx = avhdr['naxis1']
ny = avhdr['naxis2']
cx = avhdr['crpix1']
cy = avhdr['crpix2']
x0 = avhdr['crval1']
y0 = avhdr['crval2']
dx = avhdr['cd1_1']
dy = avhdr['cd2_2']
xx,yy = meshgrid(arange(nx),arange(ny))
goodind = (avmap<>kw['null'])
# I don't know how the following WCS calculation works, but it
# does -- thank you, Calabretta & Greisen 2002!
d2r = pi/180.
phi = arctan2( xx-cx+1, yy-cy+1) + pi
theta = arctan2(1./(d2r*dy), sqrt((yy-cy)**2 + (xx-cx)**2))
mapdec = arcsin(sin(theta)*sin(y0*d2r) - cos(theta)*cos(phi)*cos(y0*d2r))/d2r
mapra = arcsin(cos(theta) * sin(phi) / cos(mapdec*d2r))/d2r + x0
if kw['method']=='griddata':
ragood = mapra[goodind]
decgood = mapdec[goodind]
avgood = avmap[goodind]
if verbose:
print 'ra.shape>>' + str(ra.shape)
# TBD: Vectorize this calculation; an interpolative solution
# should exist.
avlist = []
for ii in range(len(ra)):
if verbose:
print 'ra, dec>>' + str((ra[ii], dec[ii]))
if kw['method']=='nearest':
distmap = (mapra-ra[ii])**2 + (mapdec-dec[ii])**2
# If multiple values are equally near, average them:
val = avmap[distmap==distmap.min()].mean()
avlist.append(val)
elif kw['method']=='griddata':
avlist.append(griddata(ragood, decgood, avgood, array([ra[ii]]), array([dec[ii]])))
else:
print "Invalid method specified!"
avlist.append(-1)
return avlist
def readogle(filename, **kw):
""" Read in an OGLE-II photometry map file and output the data.
Returns a 6-tuple with each element an array:
0 -- RA. Strings of Right Ascension values.
1 -- DEC. Strings of Declination values
2 -- x_ref. OGLE x-coordinate, pixels
3 -- y_ref. OGLE y-coordinate, pixels
4 -- v_mag. OGLE V magnitude
5 -- i_mag. OGLE I magnitude
If you like, use HMS and DMS to convert the RA and DEC values returned."""
# 2008-12-21 18:53 IJC: Created
f = open(filename, 'r')
raw = f.readlines()
f.close()
nstars = len(raw)
raw2 = array([line.split() for line in raw])
ra = raw2[:,1]
dec = raw2[:,2]
xref = raw2[:,3]
yref = raw2[:,4]
vmag = raw2[:,5]
imag = raw2[:,7]
xref = [map(float, [x]) for x in xref]
yref = [map(float, [y]) for y in yref]
vmag = [map(float, [v]) for v in vmag]
imag = [map(float, [i]) for i in imag]
return (ra, dec, xref, yref, vmag, imag)
def hms(d, delim=':'):
"""Convert hours, minutes, seconds to decimal degrees, and back.
EXAMPLES:
hms('15:15:32.8')
hms([7, 49])
hms(18.235097)
Also works for negative values.
SEE ALSO: dms
"""
# 2008-12-22 00:40 IJC: Created
# 2009-02-16 14:07 IJC: Works with spaced or colon-ed delimiters
from numpy import sign
if d.__class__==str or hasattr(d, '__iter__'): # must be HMS
if d.__class__==str:
d = d.split(delim)
if len(d)==1:
d = d[0].split(' ')
if (len(d)==1) and (d.find('h')>-1):
d.replace('h',delim)
d.replace('m',delim)
d.replace('s','')
d = d.split(delim)
s = sign(float(d[0]))
if s==0: s=1
degval = float(d[0])*15.0
if len(d)>=2:
degval = degval + s*float(d[1])/4.0
if len(d)==3:
degval = degval + s*float(d[2])/240.0
return degval
else: # must be decimal degrees
hour = int(d/15.0)
d = abs(d)
min = int((d-hour*15.0)*4.0)
sec = (d-hour*15.0-min/4.0)*240.0
return [hour, min, sec]
def dms(d, delim=':'):
"""Convert degrees, minutes, seconds to decimal degrees, and back.
EXAMPLES:
dms('150:15:32.8')
dms([7, 49])
dms(18.235097)
Also works for negative values.
SEE ALSO: hms
"""
# 2008-12-22 00:40 IJC: Created
# 2009-02-16 14:07 IJC: Works with spaced or colon-ed delimiters
from numpy import sign
if d.__class__==str or hasattr(d, '__iter__'): # must be HMS
if d.__class__==str:
d = d.split(delim)
if len(d)==1:
d = d[0].split(' ')
s = sign(float(d[0]))
if s==0: s=1
degval = float(d[0])
if len(d)>=2:
degval = degval + s*float(d[1])/60.0
if len(d)==3:
degval = degval + s*float(d[2])/3600.0
return degval
else: # must be decimal degrees
if d<0:
sgn = -1
else:
sgn = +1
d = abs(d)
deg = int(d)
min = int((d-deg)*60.0)
sec = (d-deg-min/60.0)*3600.0
return [sgn*deg, min, sec]
def hess(color, mag, binsize, **kw):
"""Compute a hess diagram (surface-density CMD) on photometry data.
INPUT:
color
mag
binsize -- width of bins, in magnitudes
OPTIONAL INPUT:
cbin= -- set the centers of the color bins
mbin= -- set the centers of the magnitude bins
OUTPUT:
A 3-tuple consisting of:
Cbin -- the centers of the color bins
Mbin -- the centers of the magnitude bins
Hess -- The Hess diagram array"""
# cbin = out[0]
# mbin = out[1]
# imshow(out[2])
# yticks(range(0, len(mbin), 4), mbin[range(0,len(mbin),4)])
# xticks(range(0, len(cbin), 4), cbin[range(0,len(cbin),4)])
# ylim([ylim()[1], ylim()[0]])
# 2009-02-08 23:01 IJC: Created, on a whim, for LMC data (of course)
# 2009-02-21 15:45 IJC: Updated with cbin, mbin options
from numpy import arange, zeros
defaults = dict(mbin=None, cbin=None, verbose=False)
for key in defaults:
if (not kw.has_key(key)):
kw[key] = defaults[key]
if kw['mbin']==None:
mbin = arange(mag.min(), mag.max(), binsize)
else:
mbin = array(kw['mbin']).copy()
if kw['cbin']==None:
cbin = arange(color.min(), color.max(), binsize)
else:
cbin = array(kw['cbin']).copy()
hess = zeros((len(mbin), len(cbin)), float)
for ii in range(len(cbin)):
cindex = (color<(cbin[ii]+binsize/2)) * (color>(cbin[ii]-binsize/2))
for jj in range(len(mbin)):
index = cindex * (mag<(mbin[jj]+binsize/2)) * (mag>(mbin[jj]-binsize/2))
hess[jj,ii] = index.sum()
return (cbin, mbin, hess)
def snr(mag=20, itime=1., read=24.5, sky=8.43, npix=24., zero=26.44, dark=0.0):
"""Calculate SNR of a photometric CCD observation of given parameters.
The default keyword parameters are for the CTIO Blanco MOSAIC
imager, operating in V band.
"""
# 2009-02-20 14:40 IJC: Initiated
star = itime * 10**(0.4*(zero-mag))
noise = npix * (itime*(sky+dark)+read**2)
return star * (star+noise)**-0.5
#def sens(texp, mag, npix, tdead=15., rn=8., csky=12., zp=22.8, z=1.0,h=1280., d=1.0):
def sens(texp, mag, lin=3.8e5, tdead=15., rn=8., csky=12., zp=22.8, z=1.0,h=1280., d=1.0):
""" Calculate sensitiviy for various exposure times.
texp -- 1D array of times
mag -- target magnitude
npix -- number of pixels read out
lin -- linearity limit of the detector (ADU)
tdead -- detector dead time (reset + readout) between integrations
rn -- read noise, in ADU
csky -- sky background per second, in ADU
zp -- photometric zero point (magnitude for 1 ADU/sec)
z -- airmass
h -- observatory altitude, in meters
d -- telescope mirror diameter, in meters
TBD: Flat-field noise!
For now, I impose an artificial floor to the number of pixels
needed -- it won't spread it out over less than 8.
"""
# 2009-03-13 11:48 IJC: Written based on http://arxiv.org/abs/0903.2139
from numpy import exp, log10, sqrt, floor
texp = array(texp).copy()
ctarg = 10**(0.4*(zp-mag))
Ntarg = ctarg * texp
npix = floor(Ntarg / (lin-csky)) # spread out the light
pixind = npix<8
npix[pixind] = 8
Nsky = csky * texp * npix
sScint = 0.004 * d**(-2./3.) * z**1.75 * exp(-h/8e3) * (2*texp)**-0.5
sTarg = -2.5*log10((Ntarg - sqrt(Ntarg)) / Ntarg)
sSky = -2.5*log10((Ntarg - sqrt(Nsky)) / Ntarg)
sRON = -2.5*log10((Ntarg - rn*sqrt(npix)) / Ntarg)
sTotal = sqrt(sScint**2 + sSky**2 + sRON**2)
snrpertime = sTotal * sqrt(texp+tdead)
return sTotal, snrpertime, npix
def subreg(fn, center=None, dim=None, verbose=False):
"""Load a subsection of a list of 2D FITS files.
INPUTS:
fn -- (str) filename or (list) list of filenames to load
center -- (2-tuple) (x0,y0) center of region to load.
dim -- (2-tuple) (dx,dy) sizes of region to load.
OUTPUT:
region -- (array) (N x dx x dy)-sized stack of subregions
NOTE: center can also be a list of tuples (1 per file), but dim cannot."""
# 2009-09-24 11:20 IJC: Created
print "Function subreg is deprecated; please use subreg2 (which is much faster!)"
import astropy.io.fits as pyfits
#import pyfits
from numpy import zeros, nan, concatenate, int, float, max, min
if not hasattr(fn, '__iter__'):
fn = [fn]
if not hasattr(dim, '__iter__'):
dim = [dim, dim]
nfiles = len(fn)
if (center is None) and (dim is None):
try:
temp = pyfits.getdata(fn[0], ignore_missing_end=True)
except:
temp = pyfits.getdata(fn[0])
dosubreg = False
dim = list(temp.shape)
center = dim[0]/2, dim[1]/2
if not hasattr(center[0], '__iter__'):
center = [center]*nfiles
stack = zeros((0, dim[0], dim[1]), float)
dim = [dim]*nfiles
if verbose: print "fn, center, dim",(fn,center,dim)
iter = 0
for file, cen, sz in zip(fn, center, dim):
if verbose: print "file, cen, sz", (file,cen,sz)
try:
temp = pyfits.getdata(file, ignore_missing_end=True)
except:
temp = pyfits.getdata(file)
if verbose: print "file "+file+" shape is: "+str(temp.shape)
if len(temp.shape)<>2:
print "File %s did not return a 2D FITS file! Using nan." % file
subreg = zeros((1,dx,dy))+nan
else:
temp = temp.reshape((1,)+temp.shape)
xstartval = max([0,cen[0] - (sz[0]-1)/2.]).astype(int)
xendval = min([temp.shape[1], 1+cen[0] + (sz[0]-1)/2.]).astype(int)
ystartval = max([0,cen[1] - (sz[1]-1)/2.]).astype(int)
yendval = min([temp.shape[2], 1+cen[1] + (sz[1]-1)/2.]).astype(int)
if verbose: print "subregion limits: ", xstartval,xendval,ystartval,yendval
subreg = temp[:,xstartval:xendval,ystartval:yendval]
if file==fn[0] and stack.shape[1::]<>subreg.shape:
stack = zeros((0,)+subreg.shape[1::],float)
if verbose:
print "stack.shape>>", stack.shape
print "subreg.shape>>", subreg.shape
stack=concatenate((stack,subreg),0)
iter += 1
return stack
def subreg2(fn, center=None, dim=None, verbose=False):
"""Load a subsection of a list of 2D FITS files.
INPUTS:
fn -- str, list of str, or 2- or 3D Numpy array.
i) filename to load, OR
ii) list of filenames to load, OR
iii) Numpy array of data, already loaded.
center -- (2-tuple) (x0,y0) center of region to load.
dim -- (2-tuple) (dx,dy) sizes of region to load.
OUTPUT:
region -- (array)
(N x dx x dy)-sized stack of subregions. Note that this will
always be 3D!
NOTE: center can also be a list of tuples (1 per file), but dim cannot."""
# 2009-09-24 11:20 IJC: Created
# 2011-12-15 15:53 IJMC: Updated to use memmap. MUCH faster!
# 2012-06-16 06:57 IJMC: Now 'fn' can also be a Numpy array.
import astropy.io.fits as pyfits
#import pyfits
from numpy import zeros, nan, concatenate, int, float, max, min
if not hasattr(fn, '__iter__'):
fn = [fn]
elif isinstance(fn, np.ndarray):
if fn.ndim==3:
nfiles = fn.shape[0]
elif fn.ndim==2:
fn = fn.reshape((1,)+fn.shape)
nfiles = len(fn)
if dim is not None and (not hasattr(dim, '__iter__')):
dim = [dim, dim]
if center is not None and (not hasattr(center[0], '__iter__')):
center = [center]*nfiles
if (center is None) and (dim is None):
try:
temp = pyfits.getdata(fn[0], ignore_missing_end=True)
except:
temp = pyfits.getdata(fn[0])
dosubreg = False
dim = list(temp.shape)
center = dim[0]/2, dim[1]/2
stack = zeros((0, dim[0], dim[1]), float)
dim = [dim]*nfiles
#center = [center]*nfiles
if verbose: print "fn, center, dim",(fn,center,dim)
iter = 0
for file, cen, sz in zip(fn, center, dim):
if verbose: print "file, cen, sz", (file,cen,sz)
if isinstance(file, np.ndarray):
f = file
else:
try:
f = pyfits.open(file, ignore_missing_end=True, memmap=True)
except:
f = pyfits.open(file, memmap=True)
#if verbose: print "file "+file+" shape is: "+str(temp.shape)
#if len(temp.shape)<>2:
# print "File %s did not return a 2D FITS file! Using nan." % file
# subreg = zeros((1,dx,dy))+nan
#else:
if iter==0:
if isinstance(f, np.ndarray):
temp = f.reshape((1,) + f.shape)
else:
temp = f[0].data#.reshape([1]+dim[0])
temp = temp.reshape((1,) + temp.shape)
xstartval = max([0,cen[0] - (sz[0]-1)/2.]).astype(int)
xendval = min([temp.shape[1], 1+cen[0] + (sz[0]-1)/2.]).astype(int)
ystartval = max([0,cen[1] - (sz[1]-1)/2.]).astype(int)
yendval = min([temp.shape[2], 1+cen[1] + (sz[1]-1)/2.]).astype(int)
if verbose: print "subregion limits: ", xstartval,xendval,ystartval,yendval
subreg = temp[0,xstartval:xendval,ystartval:yendval]
stack = zeros((nfiles,) + subreg.shape, float)
else:
this_dy = center[0][0] - center[iter][0]
this_dx = center[0][1] - center[iter][1]
try:
subreg = f[0].data[xstartval+this_dx:xendval+this_dx, \
ystartval+this_dy:yendval+this_dy]
except IndexError:
print "Likely invalid center position for Frame %i (%s): %s." % \
(iter, file, str(center[iter]))
print "Using offsets for Frame 0 (%s) instead." % str(center[0])
subreg = f[0].data[xstartval:xendval, ystartval:yendval]
except:
print "Some error occurred. Using offsets for Frame 0 (%s) instead." % \
str(center[0])
subreg = f[0].data[xstartval:xendval, ystartval:yendval]
stack[iter] = subreg
iter += 1
return stack
def aperphot(fn, timekey=None, pos=[0,0], dap=[2,4,6], mask=None, verbose=False, nanval=999, resamp=None, retfull=False):
"""Do aperture photometry on a specified file.
:INPUTS:
pos : 2-sequence
center of apertures (as if indexing: fn[pos[0], pos[1]])
dap : 3-sequence
Photometry aperture DIAMETERS:
-- target aperture (within which to sum flux)
-- inner sky aperture
-- outer sky aperture
resamp : int
Factor by which to interpolate frame before measuring photometry
(in essence, does partial-pixel aperture photometry)
Aperture masking:
If no mask is passed in, use the star's input position and
aperture diameters to create binary pixel masks for stellar and
background photometry. If a mask is passed in, stellar and
background aperture masks are generated from where all input
mask elements equal 1 and 2, respectively.
retfull:
Also return arrays of target mask, sky mask, and frame used.
This option is a memory hog!
:OUTPUTS:
:class:`phot` object.
:EXAMPLE:
::
import astropy.io.fits
from astropy import wcs
import numpy as np
from phot import aperphot
img='62_z_CDFs_goods_stamp_img.fits' #path to the image
RA = 52.9898239
DEC = -27.7143114
hdulist = astropy.io.fits.open(img)
w = wcs.WCS(hdulist['PRIMARY'].header)
world = np.array([[RA, DEC]])
pix = w.wcs_world2pix(world,1) # Pixel coordinates of (RA, DEC)
print "Pixel Coordinates: ", pix[0,0], pix[0,1]
#call aperture function
observation=aperphot(img, timekey=None, pos=[pix[0,0], pix[0,1]], dap=[4,8,12], resamp=2, retfull=False)
# Print outputs
print "Aperture flux:", observation.phot
print "Background: ", observation.bg
:REQUIREMENTS:
scipy.interpolate, pyfits, numpy...
"""
# 2009-09-14 10:49 IJC: Created
# 2010-01-15 14:20 IJC: Added numpy "_string" check
# 2011-12-29 12:01 IJMC: Added peak pixel values to photometry report.
# 2012-01-25 11:26 IJMC: Adding "resamp" option -- thanks to
# K. Stevenson and J. Harrington of UCF for
# the suggestion.
# 2012-02-26 11:53 IJMC: Now return 'ntarg' and 'nsky' -- number of pixels used.
# 2012-06-07 08:27 IJMC: 'peak' values are now corrected for the
# resampling factor.
# 2012-07-03 10:35 IJMC: Fixed a key bug: frames were not
# correctly background-subtracted when
# applying partial-pixel resampling.
# 2012-10-19 13:41 IJMC: Documented 'retfull' option; changed default.
# 2013-03-20 09:21 IJMC: More error-checking for saving header
# keywords. Thanks to A. Weigel @
# ETH-Zurich for catching this!
# 2014-05-06 13:12 JXP: Eliminate fixval calls
from numpy import meshgrid, median,isfinite,sort,ndarray,string_
import numpy as np
import astropy.io.fits as pyfits
#import pyfits
#from xastropy.phot.ian_analysis import fixval
from os import path
from scipy import interpolate
thisobs = phot()
x0, y0 = pos
dap_targ, dap_skyinner, dap_skyouter = dap
if resamp is None or resamp<1:
resamp = 1
else:
resamp = float(resamp)
# Determine size:
if isinstance(fn,str):
nx = pyfits.getval(fn, 'NAXIS1')
ny = pyfits.getval(fn, 'NAXIS2')
elif isinstance(fn,ndarray):
nx,ny = fn.shape
nx0, ny0 = nx, ny
nx = ((nx - 1)*resamp + 1.) # Avoid resampling at pixel locations
ny = ((ny - 1)*resamp + 1.) # outside the original boundaries.
# Generate or load masks:
if mask==None:
xx,yy = meshgrid(np.arange(nx)/resamp, np.arange(ny)/resamp) # JXP 2014 May 6
#xx,yy = meshgrid(np.arange(ny)/resamp, np.arange(nx)/resamp)
mask_targ = makemask(xx, yy, (x0, y0, dap_targ))
mask_s1 = makemask(xx, yy, (x0,y0, dap_skyinner))
mask_s2 = makemask(xx, yy, (x0,y0, dap_skyouter))
mask_sky = mask_s2 - mask_s1
else:
mask_targ = mask==1
mask_sky = mask==2
if resamp>1:
print "In aperphot, resamp>1 and user-specified mask passed in... beware!"
# Load data frame:
thisobs = phot()
if isinstance(fn,ndarray):
frame = fn
elif isinstance(fn, str) or isinstance(fn,string_):
if not path.isfile(fn):
print "file %s not found! exiting..." % fn
return thisobs
frame = pyfits.getdata(fn)
#fixval(frame, nanval)
# Resample data frame
if resamp>1:
frame0 = frame.copy()
xx0 = range(nx0)
yy0 = range(ny0)
x1,y1 = np.arange(nx)/resamp, np.arange(ny)/resamp
rectspline = interpolate.fitpack2.RectBivariateSpline(xx0, yy0, frame0, kx=1, ky=1, s=0)
frame = rectspline(x1, y1)
#from pylab import *
# Measure background and aperture photometry
thisbg, thisebg = estbg(frame, mask=mask_sky, plotalot=verbose, rout=[3,99])
thisphot = (mask_targ*(frame - thisbg)).sum() /resamp/resamp
peak = frame.max()
peak_targ = (mask_targ * frame).max()
peak_annulus = (mask_sky * frame).max()
#pdb.set_trace()
thisobs.bg=thisbg
thisobs.ebg=thisebg
thisobs.bgstr='phot.estbg: SDOM on bg histogram mean & dispersion after outlier rejection'
thisobs.phot=thisphot
thisobs.photstr='by-hand background-subtracted aperture photometry'
thisobs.ntarg = mask_targ.sum()/resamp/resamp
thisobs.nsky = mask_sky.sum()/resamp/resamp
#pdb.set_trace()
# Simple stats :: JXP 2014 May 6
var = thisphot + np.sqrt(thisobs.nsky)*thisobs.bg
thisobs.ephot = np.sqrt(var)
thisobs.peak = peak
thisobs.peak_targ = peak_targ
thisobs.peak_annulus = peak_annulus
thisobs.peakstr = 'peak pixel value in frame'
thisobs.peak_targstr = 'peak pixel value in target aperture'
thisobs.peak_annulusstr = 'peak pixel value in sky annulus'
thisobs.position = pos
thisobs.positionstr = 'user-specified, zero-indexed pixel coordinates.'
if isinstance(fn, str):
header = pyfits.getheader(fn)
if not timekey==None:
if timekey in header:
thisobs.time=header['timekey']
thisobs.timestr='heliocentric modified julian date'
if 'object' in header: thisobs.object = header['object']
if 'exptime' in header: thisobs.exptime = header['exptime']
thisobs.aper = dap
thisobs.aperstr = 'target, inner, outer aperture diameters, in pixels.'
thisobs.filename=fn
thisobs.resamp = resamp
if retfull:
thisobs.mask_targ = mask_targ
thisobs.mask_sky = mask_sky
thisobs.frame = frame
if verbose:
from pylab import figure, colorbar
from nsdata import imshow
figure(); imshow(frame*mask_targ); colorbar()
figure(); imshow(frame*mask_sky); colorbar()
return thisobs
def psffiterr(xyoffset, psf, frame, w=None, scale=100, dframe=9, verbose=False):
""" Usage:
optimize.fmin_powell(psffiterr, [0,0], args=(psf, stack[6],goodind[6],100,13),xtol=0.5,ftol=1)
"""
# 2009-11-13 11:27 IJC: Created
from numpy import round
import pdb
out = psffit(psf, frame, loc=None, w=w, scale=scale, dframe=dframe, \
xoffs=[round(xyoffset[0])], yoffs=[round(xyoffset[1])], verbose=verbose)
sumsqres = out[2][0,0]
#pdb.set_trace()
return sumsqres
def psffit(psf, frame, loc=None, w=None, scale=100, dframe=9, xoffs=range(0,100,10), yoffs=range(0,100,10), verbose=False):
"""
INPUT:
psf -- model PSF (supersampled by 'scale')
frame -- science frame to which psf will be fit. best if it's odd-sized
OPTIONAL INPUTS:
loc -- (x,y) integers, star location in data frame (e.g., data[x,y])
w -- [array] weights of pixels in data frame, (typ. 1/sigma^2)
scale -- supersampling level of PSF
dframe -- [odd int] diameter of square box around target location
xoffs -- [int array] subpixel x offsets to test.
yoffs -- [int array] subpixel y offsets to test.
"""
# 2009-10-07 14:18 IJC: Created.
# 2011-05-11 22:16 IJC: Added a try/except/pdb debugging step
from numpy import arange, prod, zeros,vstack,dot, nonzero, diag,floor,abs,max,hstack
from numpy.linalg import pinv
from xastropy.phot.ian_analysis import binarray
from time import time
import pdb
tic = time()
if w==None:
w = zeros(frame.shape)+1
if loc==None:
loc = ((frame.shape[1]-1)/2,(frame.shape[0]-1)/2)
if xoffs==None:
xoffsets = arange(scale) #arange(scale)
if yoffs==None:
yoffs = arange(scale) #arange(scale)
ycen = int(loc[0])
xcen = int(loc[1])
pycen, pxcen = nonzero(psf==psf.max())
# Pick a thumbnail frame size to use, and cut it out of the larger frame
if verbose:
print "frame.shape>>", frame.shape
print "(xcen, ycen, dframe)>>", xcen,ycen,dframe
print "limits>>" , (ycen-(dframe-1)/2.), (ycen+(dframe+1)/2.), (xcen-(dframe-1)/2.), (xcen+(dframe+1)/2.)
print "xoffs, yoffs>>", xoffs, yoffs
data = frame[(ycen-(dframe-1)/2.):(ycen+(dframe+1)/2.),
(xcen-(dframe-1)/2.):(xcen+(dframe+1)/2.)]
weights = w[(ycen-(dframe-1)/2.):(ycen+(dframe+1)/2.),
(xcen-(dframe-1)/2.):(xcen+(dframe+1)/2.)]
wmat = diag(weights.ravel())
extrasize = 2*max(abs(floor(1.0*hstack((xoffs,yoffs))/scale)))
exs = extrasize*scale/2
if verbose: print "extrasize>> ",extrasize
# Determine how much of the PSF to cut out, and cut it out
dpsf0 = (dframe+1)*scale-1
dpsf1 = dframe*scale-1
pxmin = int(pxcen-(dpsf0-1)/2-exs)
pxmax = int(pxcen+(dpsf0+1)/2+exs)
pymin = int(pycen-(dpsf0-1)/2-exs)
pymax = int(pycen+(dpsf0+1)/2+exs)
if verbose: print psf.shape, pymin, pymax, pxmin, pxmax
smpsf = psf[pymin:pymax, pxmin:pxmax]
if verbose: print "data.shape>>" , data.shape
ndata = prod(data.shape)
if verbose: print "ndata>> %i" % ndata
const = zeros(ndata,float)+1
background = zeros((len(xoffs),len(yoffs)), float)
fluxscale = zeros((len(xoffs),len(yoffs)), float)
chisq = zeros((len(xoffs),len(yoffs)), float)
if verbose:
print "wmat.shape>>", wmat.shape
print "data.ravel().shape>>", data.ravel().shape
wpmat = dot(wmat, data.ravel()) # outside of loop for efficiency
dfs = dframe * scale # outside of loop for efficiency
initoffset_min = scale - 1 + exs # outside of loop for efficiency
initoffset_max = scale - 1 + exs + dfs # outside of loop for efficiency
nx = len(xoffs)
ny = len(yoffs)
rangeny = range(ny)
for ii in range(nx):
xoffset = xoffs[ii]
xmin, xmax = int(initoffset_min-xoffset), int(initoffset_max-xoffset)
for jj in rangeny:
# Cut out the correct portion of the model PSF
yoffset = yoffs[jj]
ymin, ymax = int(initoffset_min-yoffset), int(initoffset_max-yoffset)
# Bin down the PSF by the correct factor. Sizes should now match!
binpsf = binarray(smpsf[ymin:ymax, xmin:xmax],scale)
# Compute the best-fit background & PSF scaling factor
if verbose:
print "xmat shapes>> ",const.shape, binpsf.ravel().shape
print "ymin,ymax,xmin,xmax>> ",ymin,ymax, xmin,xmax
print "binpsf.shape>> ",binpsf.shape
try:
xmat = vstack((const,binpsf.ravel())).transpose()
wxmat = dot(wmat,xmat)
fitvec = dot(pinv(wxmat), wpmat)
background[ii,jj], fluxscale[ii,jj] = fitvec
chisq[ii,jj] = ((dot(wxmat, fitvec) - wpmat)**2).sum()
except:
print "error occurred"
chisq[ii,jj] = 9e99
pdb.set_trace()
ii,jj = nonzero(chisq==chisq.min())
if len(ii)>1: # more than one chisquared minimum found!
ii = ii[0]
jj = jj[0]
xoffset = xoffs[ii]
xmin, xmax = int(scale-xoffset-1+exs), int(scale-xoffset-1 + dfs+exs)
yoffset = yoffs[jj]
ymin, ymax = int(scale-yoffset-1+exs), int(scale-yoffset-1 + dfs+exs)
# Bin down the PSF by the correct factor. Sizes should now match!
binpsf = binarray(smpsf[ymin:ymax, xmin:xmax],scale)
modelpsf = background[ii,jj]+fluxscale[ii,jj]*binpsf
#print "%f seconds for completion!" % (time()-tic)
return modelpsf, data, chisq, background, fluxscale, xoffset, yoffset, chisq[ii,jj],background[ii,jj], fluxscale[ii,jj]
def prffit(prf, frame, loc=None, w=None, scale=100, dframe=9, xoffs=range(0,100,10), yoffs=range(0,100,10), verbose=False):
"""
INPUT:
prf -- model PRF (supersampled by 'scale')
frame -- science frame to which psf will be fit. best if it's odd-sized
OPTIONAL INPUTS:
loc -- (x,y) integers, star location in data frame (e.g., data[x,y])
w -- [array] weights of pixels in data frame, (typ. 1/sigma^2)
scale -- supersampling level of PSF
dframe -- [odd int] diameter of square box around target location
xoffs -- [int array] subpixel x offsets to test.
yoffs -- [int array] subpixel y offsets to test.
"""
# 2009-10-07 14:18 IJC: Created.
from numpy import arange, prod, zeros,vstack,dot, nonzero, diag,floor,abs,max,hstack
from numpy.linalg import pinv
from xastropy.phot.ian_analysis import binarray
from time import time
tic = time()
if w==None:
w = zeros(frame.shape)+1
if loc==None:
loc = ((frame.shape[1]-1)/2,(frame.shape[0]-1)/2)
if xoffs==None:
xoffsets = arange(scale) #arange(scale)
if yoffs==None:
yoffs = arange(scale) #arange(scale)
ycen = int(loc[0])
xcen = int(loc[1])
pycen, pxcen = nonzero(prf==prf.max())
# Pick a thumbnail frame size to use, and cut it out of the larger frame
if verbose:
print "frame.shape>>", frame.shape
print "(xcen, ycen, dframe)>>", xcen,ycen,dframe
print "limits>>" , (ycen-(dframe-1)/2.), (ycen+(dframe+1)/2.), (xcen-(dframe-1)/2.), (xcen+(dframe+1)/2.)
data = frame[(ycen-(dframe-1)/2.):(ycen+(dframe+1)/2.),
(xcen-(dframe-1)/2.):(xcen+(dframe+1)/2.)]
weights = w[(ycen-(dframe-1)/2.):(ycen+(dframe+1)/2.),
(xcen-(dframe-1)/2.):(xcen+(dframe+1)/2.)]
wmat = diag(weights.ravel())
extrasize = 2*max(abs(floor(1.0*hstack((xoffs,yoffs))/scale)))
exs = extrasize*scale/2
if verbose: print "extrasize>> ",extrasize
if verbose: print "data.shape>>" , data.shape
ndata = prod(data.shape)
if verbose: print "ndata>> %i" % ndata
const = zeros(ndata,float)+1
background = zeros((len(xoffs),len(yoffs)), float)
fluxscale = zeros((len(xoffs),len(yoffs)), float)
chisq = zeros((len(xoffs),len(yoffs)), float)
if verbose:
print "wmat.shape>>", wmat.shape
print "data.ravel().shape>>", data.ravel().shape
wpmat = dot(wmat, data.ravel()) # outside of loop for efficiency
dfs = dframe * scale # outside of loop for efficiency
initoffset_min = scale - 1 + exs # outside of loop for efficiency
initoffset_max = scale - 1 + exs + dfs # outside of loop for efficiency
nx = len(xoffs)
ny = len(yoffs)
rangeny = range(ny)
for ii in range(nx):
xoffset = xoffs[ii]
xmin, xmax = int(initoffset_min-xoffset), int(initoffset_max-xoffset)
for jj in rangeny:
# Extract the correct indices of the model PRF. Sizes should now match!
yoffset = yoffs[jj]
ymin, ymax = int(initoffset_min-yoffset), int(initoffset_max-yoffset)
binpsf = prf[indy, indx]
# Compute the best-fit background & PSF scaling factor
if verbose and (ii==0) and (jj==0):
print "xmat shapes>> ",const.shape, binpsf.ravel().shape
print "ymin,ymax,xmin,xmax>> ",ymin,ymax, xmin,xmax
print "binpsf.shape>> ",binpsf.shape
xmat = vstack((const,binpsf.ravel())).transpose()
wxmat = dot(wmat,xmat)
fitvec = dot(pinv(wxmat), wpmat)
background[ii,jj], fluxscale[ii,jj] = fitvec
chisq[ii,jj] = ((dot(wxmat, fitvec) - wpmat)**2).sum()
ii,jj = nonzero(chisq==chisq.min())
if len(ii)>1: # more than one chisquared minimum found!
ii = ii[0]
jj = jj[0]
xoffset = xoffs[ii]
xmin, xmax = int(scale-xoffset-1+exs), int(scale-xoffset-1 + dfs+exs)
yoffset = yoffs[jj]
ymin, ymax = int(scale-yoffset-1+exs), int(scale-yoffset-1 + dfs+exs)
# Bin down the PSF by the correct factor. Sizes should now match!
binpsf = binarray(smpsf[ymin:ymax, xmin:xmax],scale)
modelpsf = background[ii,jj]+fluxscale[ii,jj]*binpsf
print "%f seconds for completion!" % (time()-tic)
return modelpsf, data, chisq, background, fluxscale, xoffset, yoffset, chisq[ii,jj],background[ii,jj], fluxscale[ii,jj]
def gauss2d(param, x, y):
""" Compute a gaussian distribution at the points x, y.
p is a three- or four-component array, list, or tuple:
z = [p4 +] p0/(p1*sqrt(4pi)) * exp(-r**2 / (2*p1**2))
where r = sqrt((x-p2)**2 + (y-p3)**2)
p[0] -- Volume under the gaussian
p[1] -- one-sigma dispersion
p[2] -- X- offset of center
p[3] -- Y- offset of center
p[4] -- optional constant, vertical offset
x & y must be equal-sized arrays from numpy.meshgrid
NOTE: FWHM = 2*sqrt(2*ln(2)) * p1 ~ 2.3548*p1
SEE ALSO: egauss2d, numpy.meshgrid"""
#2010-01-11 22:46 IJC: Created
from numpy import array, abs, concatenate, exp
x = array(x, dtype=float).copy()
y = array(y, dtype=float).copy()
p = array(param).copy()
r = abs((x-p[2]) + 1j*(y-p[3]))
if len(p)==4:
p = concatenate((p, [0]))
z = p[4] + p[0]/(p[1]*4*pi) * exp(-r**2 / (2*p[1]**2))
return z
def egauss2d(param, x, y, z, ez=None):
""" Return the chi-squared error on a 2D gaussian fit. See gauss2d
for more details on the input parameters.
z is the array of data to be fit
ez is an optional array of one-sigma errors to the data in z.
"""
# 2010-01-11 22:59 IJC: Created
from numpy import array, float, ones
x = array(x, dtype=float).copy()
y = array(y, dtype=float).copy()
z = array(z, dtype=float).copy()
p = array(param).copy()
if ez==None:
ez = ones(z.shape,float)
else:
ez = array(ez, dtype=float).copy()
model = gauss2d(param,x,y)
chisq = (((z-model)/ez)**2).sum()
return chisq
| bsd-3-clause |
schae234/Camoco | tests/test_COB.py | 2 | 5362 | '''
COB Tests
'''
import camoco as co
from camoco import cf
import random
import itertools
from collections import Counter
import pytest
import pandas as pd
import numpy as np
from scipy.misc import comb
def test_coordination_between_expr_and_expr_index(testCOB):
for i,x in enumerate(testCOB._expr.index):
assert i == testCOB._expr_index[x]
def test_coordination_between_expr_index_and_coex_index(testCOB):
assert True
return
assert set(itertools.chain(*testCOB.coex.index.values)) \
== set(testCOB._expr.index.values)
def test_expr_nans_in_same_place(testCOB):
pass
def test_shape(testCOB):
assert len(testCOB.coex) == comb(testCOB.num_genes(), 2)
def test_coex_score_concordance(testCOB):
for a, b in itertools.combinations(
[testCOB.refgen.random_gene() for x in range(cf.test.num)], 2
):
assert (
abs(
testCOB.coexpression(a, b).score \
- testCOB._coex_concordance(a, b)) < 0.001
) or ( np.isnan(testCOB.coexpression(a, b).score)
and np.isnan(testCOB._coex_concordance(a, b))
)
def test_coex_distance_concordance(testCOB):
for a, b in itertools.combinations(
[testCOB.refgen.random_gene() for x in range(cf.test.num)], 2
):
dis_dif = abs(testCOB.coexpression(a, b).distance - abs(a-b))
assert np.isnan(dis_dif) or dis_dif < 100
def test_coex_id_concordance(testCOB):
for a, b in itertools.combinations(
[testCOB.refgen.random_gene() for x in range(cf.test.num)], 2
):
assert sorted(testCOB.coexpression(a,b).name) == sorted([a.id,b.id])
def test_coex_to_expr_concordance(testCOB):
'''
Translate expr indexes to coex indexes and back again
'''
# Get Random set of expr indexes
expr_len = testCOB._expr.shape[0]
expr_idxs = np.sort(np.unique(np.array(
[random.randint(0,expr_len-1) for i in range(cf.test.num*10)]
)))
# Translate them back and forth
coex_idxs = co.PCCUP.coex_index(expr_idxs, expr_len)
new_expr_idxs = co.PCCUP.coex_expr_index(coex_idxs, expr_len).flatten()
# Check all elements are the same in both
if not (expr_idxs.shape[0] == np.unique(new_expr_idxs).shape[0]):
assert False
res = (expr_idxs == np.unique(new_expr_idxs))
if not (np.sum(res) == res.shape[0]):
assert False
# Check all values occur the proper number of times
corr_count = len(expr_idxs)-1
bad_vals = []
for k,v in Counter(new_expr_idxs).items():
if not (v == corr_count):
bad_vals.append((k,v))
assert bad_vals == []
def test_num_neighbors_equals_degree(testCOB):
random_gene = testCOB.refgen.random_gene()
assert len(testCOB.neighbors(random_gene)) \
== testCOB.global_degree(random_gene)
assert len(testCOB.neighbors(random_gene,return_gene_set=True)) \
== testCOB.global_degree(random_gene)
assert len(testCOB.neighbors(random_gene,names_as_index=False)) \
== testCOB.global_degree(random_gene)
def test_subnetwork_contains_only_input_genes(testCOB):
random_genes = set(testCOB.refgen.random_genes(n=cf.test.num))
subnet = testCOB.subnetwork(random_genes,sig_only=False)
assert set(itertools.chain(*subnet.index.values)) == set([x.id for x in random_genes])
def test_subnetwork_contains_only_input_when_duplicates(testCOB):
random_genes = list(testCOB.refgen.random_genes(n=cf.test.num))
# Add duplicates
random_genes = random_genes + random_genes[-10:-1]
subnet = testCOB.subnetwork(random_genes,sig_only=False)
assert set(itertools.chain(*subnet.index.values)) == set([x.id for x in random_genes])
def test_degree_index_matches_degree(testCOB):
# Compare the degree determined from subnetwork aggregation
# is the same as what is in the data frame
for k,v in Counter(itertools.chain(*testCOB.subnetwork().index.values)).items():
assert testCOB.degree.ix[k].Degree == v
def test_empty_subnetwork_returns_proper_dataframe(testCOB):
subnet = testCOB.subnetwork([])
assert len(subnet) == 0
assert 'score' in subnet.columns
assert 'significant' in subnet.columns
assert 'distance' in subnet.columns
def test_zero_index_genes_doesnt_get_filtered(testCOB):
''' ---- Regression bug
This bug occured when one of the genes in the subnetwork list
had an index of 0, which was filtered out because the list filter
function thought it was None
'''
# get the first gene in the matrix
gene_a = testCOB.refgen[testCOB._expr.index[0]]
# get a random gene
gene_b = testCOB.refgen.random_gene()
# make sure that the subnetwork contains a single coexpression
# entry between genes
assert len(testCOB.subnetwork([gene_a,gene_b],sig_only=False)) == 1
def test_zero_degree_genes_return_empty_dataframe(testCOB):
# get a random zero degree gene
gene_id = testCOB.degree.ix[testCOB.degree.Degree==0].sample(1).index[0]
gene = testCOB.refgen[gene_id]
assert len(testCOB.neighbors(gene)) == 0
def test_repr(testCOB):
assert repr(testCOB).startswith('<COB:')
def test_str(testCOB):
assert str(testCOB).startswith('<COB:')
def test_qc_gene(testCOB):
assert isinstance(testCOB.qc_gene(),pd.DataFrame)
| mit |
nschloe/python4gmsh | test/occ/helpers.py | 6 | 2631 | import math
import numpy as np
def prune_nodes(points, cells):
# Only points/cells that actually used
uvertices, uidx = np.unique(cells, return_inverse=True)
cells = uidx.reshape(cells.shape)
points = points[uvertices]
return points, cells
def get_triangle_volumes(pts, cells):
# Works in any dimension; taken from voropy
local_idx = np.array([[1, 2], [2, 0], [0, 1]]).T
idx_hierarchy = cells.T[local_idx]
half_edge_coords = pts[idx_hierarchy[1]] - pts[idx_hierarchy[0]]
ei_dot_ej = np.einsum(
"ijk, ijk->ij", half_edge_coords[[1, 2, 0]], half_edge_coords[[2, 0, 1]]
)
vols = 0.5 * np.sqrt(
+ei_dot_ej[2] * ei_dot_ej[0]
+ ei_dot_ej[0] * ei_dot_ej[1]
+ ei_dot_ej[1] * ei_dot_ej[2]
)
return vols
def get_simplex_volumes(pts, cells):
"""Signed volume of a simplex in nD. Note that signing only makes sense for
n-simplices in R^n.
"""
n = pts.shape[1]
assert cells.shape[1] == n + 1
p = pts[cells]
p = np.concatenate([p, np.ones(list(p.shape[:2]) + [1])], axis=-1)
return np.abs(np.linalg.det(p) / math.factorial(n))
def compute_volume(mesh):
if "tetra" in mesh.cells_dict:
vol = math.fsum(
get_simplex_volumes(*prune_nodes(mesh.points, mesh.cells_dict["tetra"]))
)
elif "triangle" in mesh.cells_dict or "quad" in mesh.cells_dict:
vol = 0.0
if "triangle" in mesh.cells_dict:
# triangles
vol += math.fsum(
get_triangle_volumes(
*prune_nodes(mesh.points, mesh.cells_dict["triangle"])
)
)
if "quad" in mesh.cells_dict:
# quad: treat as two triangles
quads = mesh.cells_dict["quad"].T
split_cells = np.column_stack(
[[quads[0], quads[1], quads[2]], [quads[0], quads[2], quads[3]]]
).T
vol += math.fsum(
get_triangle_volumes(*prune_nodes(mesh.points, split_cells))
)
else:
assert "line" in mesh.cells_dict
segs = np.diff(mesh.points[mesh.cells_dict["line"]], axis=1).squeeze()
vol = np.sum(np.sqrt(np.einsum("...j, ...j", segs, segs)))
return vol
def plot(filename, points, triangles):
from matplotlib import pyplot as plt
pts = points[:, :2]
for e in triangles:
for idx in [[0, 1], [1, 2], [2, 0]]:
X = pts[e[idx]]
plt.plot(X[:, 0], X[:, 1], "-k")
plt.gca().set_aspect("equal", "datalim")
plt.axis("off")
# plt.show()
plt.savefig(filename, transparent=True)
| bsd-3-clause |
kpegion/SubX | Python/NAO_index/point_based/createNAO_index_template.py | 1 | 2998 | """ Create NAO index.
The file is filled in by generate_NAO_index.ksh.
"""
import os
import xarray as xr
import pandas as pd
# Sections of code to run
forecast = 1 # 1, 0
mme_forecast = 0 # 1, 0
ERA_Interim = 0 # 1, 0
# Inputs
moPath = 'moddir'
ft = 'ftype'
mo = 'mod'
ins = 'inst'
va = 'var'
pl = plev
nyv = nlat.0
nxv = nlon.0
syv = slat.0
sxv = slon.0
subsampletime = subsampleS
starttime = 'startS'
endtime = 'endS'
obsPath = 'obsdir'+va+'/'+str(pl)+'/'
nysave = str(int(nyv))
nxsave = str(int(nxv))
sysave = str(int(syv))
sxsave = str(int(sxv))
anomDir = moPath+ft+'/'+mo+'/'+va+'/'+str(pl)+'/daily/anom/'
anomfname = 'daily_anomalies.y'
obsanomPath = obsPath+'daily/SubX/anom/'
obsanomfname = 'daily_anomalies.y'
NAOpath = moPath+ft+'/'+mo+'/'+va+'/'+str(pl)+'/daily/NAO/point_based/'
if not os.path.isdir(NAOpath):
os.makedirs(NAOpath)
obsNAOpath = obsPath+'daily/SubX/NAO/point_based/'
if not os.path.isdir(obsNAOpath):
os.makedirs(obsNAOpath)
NAOfname = 'np.y'+nysave+'.x'+nxsave+'.sp.y'+sysave+'.x'+sxsave+'.nc'
obsNAOfname = 'np.y'+nysave+'.x'+nxsave+'.sp.y'+sysave+'.x'+sxsave+\
'.SubX.'+mo+'.nc'
# Sub-sample time
if 0 == subsampletime:
_rd = xr.open_dataarray(url+ins+'/.'+mo+'/.'+ft+'/.'+va+'/dods')
starttime = pd.Timestamp(_rd.S.values[0]).strftime('%Y-%m-%d')
endtime = pd.Timestamp(_rd.S.values[-1]).strftime('%Y-%m-%d')
# Update file names
anomfname = starttime+'.'+endtime+'.'+anomfname
obsanomfname = starttime+'.'+endtime+'.'+obsanomfname
NAOfname = starttime+'.'+endtime+'.'+NAOfname
obsNAOfname = starttime+'.'+endtime+'.'+obsNAOfname
if forecast == 1:
# Read in north point
nda = xr.open_dataarray(anomDir+anomfname+nysave+'.x'+nxsave+'.nc')
# Read in south point
sda = xr.open_dataarray(anomDir+anomfname+sysave+'.x'+sxsave+'.nc')
# Loop over ensembles
for i, e in enumerate(nda.M):
esave = str(int(e))
_np = nda.sel(M=e)
_sp = sda.sel(M=e)
nao = (_sp - _np) / (_sp - _np).std(dim='S')
nao.attrs['long_name'] = 'NAO'
nao.to_netcdf(NAOpath+'e'+esave+'.'+NAOfname)
# Ensemble mean
_np = nda.mean(dim='M')
_sp = sda.mean(dim='M')
nao = (_sp - _np) / (_sp - _np).std(dim='S')
nao.attrs['long_name'] = 'NAO'
nao.to_netcdf(NAOpath+'emean.'+NAOfname)
if mme_forecast == 1:
nda = xr.open_dataarray(anomDir+anomfname+nysave+'.x'+nxsave+'.nc')
sda = xr.open_dataarray(anomDir+anomfname+sysave+'.x'+sxsave+'.nc')
nao = (sda - nda) / (sda - nda).std(dim='S')
nao.attrs['long_name'] = 'NAO'
nao.to_netcdf(NAOpath+'emean.'+NAOfname)
if ERA_Interim == 1:
nda = xr.open_dataarray(obsanomPath+obsanomfname+nysave+'.x'+nxsave+\
'.SubX.'+mo+'.nc')
sda = xr.open_dataarray(obsanomPath+obsanomfname+sysave+'.x'+sxsave+\
'.SubX.'+mo+'.nc')
nao = (sda - nda) / (sda - nda).std(dim='S')
nao.attrs['long_name'] = 'NAO'
nao.to_netcdf(obsNAOpath+obsNAOfname)
| mit |
stscieisenhamer/ginga | ginga/util/toolbox.py | 1 | 5038 | #
# toolbox.py -- Goodies for enhancing a Ginga viewer
#
# This is open-source software licensed under a BSD license.
# Please see the file LICENSE.txt for details.
#
from __future__ import (absolute_import, division, print_function,
unicode_literals)
# STDLIB
import io
import os
import warnings
# THIRD-PARTY
from astropy.utils.data import get_pkg_data_contents
from astropy.utils.exceptions import AstropyUserWarning
class ModeIndicator(object):
"""
This class adds a mode status indicator to a viewer's lower right-hand
corner.
Usage:
Instantiate this class with a Ginga ImageView{Toolkit} object as the
sole constructor argument. Save a reference to the mode indicator
object somewhere so it doesn't get collected.
"""
def __init__(self, viewer):
self.viewer = viewer
# set to false to disable
self.visible = True
self.fontsize = 12
# for displaying modal keyboard state
self.mode_obj = None
bm = viewer.get_bindmap()
bm.add_callback('mode-set', self.mode_change_cb)
viewer.add_callback('configure', self._configure_cb)
def mode_change_cb(self, bindmap, mode, modetype):
# delete the old indicator
obj = self.mode_obj
self.mode_obj = None
#canvas = self.viewer.get_canvas()
canvas = self.viewer.private_canvas
if obj:
try:
canvas.delete_object(obj)
except:
pass
if not self.visible:
return True
# if not one of the standard modifiers, display the new one
if not mode in (None, 'ctrl', 'shift'):
Text = canvas.get_draw_class('text')
Rect = canvas.get_draw_class('rectangle')
Compound = canvas.get_draw_class('compoundobject')
if modetype == 'locked':
text = '%s [L]' % (mode)
elif modetype == 'softlock':
text = '%s [SL]' % (mode)
else:
text = mode
xsp, ysp = 4, 6
wd, ht = self.viewer.get_window_size()
wd, ht = int(wd), int(ht)
if self.viewer._originUpper:
x1, y1 = wd-self.fontsize*len(text), ht-self.fontsize
else:
# matplotlib case
x1, y1 = wd-self.fontsize*len(text), self.fontsize
o1 = Text(x1, y1, text,
fontsize=self.fontsize, color='yellow', coord='canvas')
wd, ht = self.viewer.renderer.get_dimensions(o1)
# yellow text on a black filled rectangle
if self.viewer._originUpper:
a1, b1, a2, b2 = x1-xsp, y1+ysp, x1+wd+xsp, y1-ht
else:
# matplotlib case
a1, b1, a2, b2 = x1-xsp, y1-ysp, x1+wd+2*xsp, y1+ht+ysp
o2 = Compound(Rect(a1, b1, a2, b2,
color='black', coord='canvas',
fill=True, fillcolor='black'),
o1)
self.mode_obj = o2
canvas.add(o2)
return True
def _configure_cb(self, view, width, height):
# redraw the mode indicator since the window has been resized
bm = view.get_bindmap()
mode, modetype = bm.current_mode()
self.mode_change_cb(bm, mode, modetype)
def generate_cfg_example(config_name, cfgpath='examples/configs', **kwargs):
"""Generate config file documentation for a given config name.
If found, it will be a Python code block of the contents.
If not found, it will have a generic message that the config
is not available.
Parameters
----------
config_name : str
Config name that is attached to the configuration file.
This is the same as input for ``prefs.createCategory()``.
For example, ``'general'``, ``'channel_Image'``, or
``'plugin_Zoom'``.
cfgpath : str
Where it is within package data.
kwargs : dict
Optional keywords for :func:`~astropy.utils.data.get_pkg_data_contents`.
Returns
-------
docstr : str
Docstring to be inserted into documentation.
"""
cfgname = config_name + '.cfg'
try:
cfgdata = get_pkg_data_contents(
os.path.join(cfgpath, cfgname), **kwargs)
except Exception as e:
warnings.warn(str(e), AstropyUserWarning)
return ''
homepath = '~' # Symbol for HOME for doc only, not actual code
userfile = os.path.join(homepath, '.ginga', cfgname)
docstring = io.StringIO()
docstring.write("""It is customizable using ``{0}``, where ``{1}``
is your HOME directory:
.. code-block:: Python
""".format(userfile, homepath))
for line in cfgdata.split('\n'):
line = line.strip()
if len(line) == 0:
docstring.write('\n') # Prevent trailing spaces
else:
docstring.write(' {0}\n'.format(line))
return docstring.getvalue()
#END
| bsd-3-clause |
kushalbhola/MyStuff | Practice/PythonApplication/env/Lib/site-packages/pandas/io/stata.py | 1 | 108362 | """
Module contains tools for processing Stata files into DataFrames
The StataReader below was originally written by Joe Presbrey as part of PyDTA.
It has been extended and improved by Skipper Seabold from the Statsmodels
project who also developed the StataWriter and was finally added to pandas in
a once again improved version.
You can find more information on http://presbrey.mit.edu/PyDTA and
http://www.statsmodels.org/devel/
"""
from collections import OrderedDict
import datetime
from io import BytesIO
import os
import struct
import sys
import warnings
from dateutil.relativedelta import relativedelta
import numpy as np
from pandas._libs.lib import infer_dtype
from pandas._libs.writers import max_len_string_array
from pandas.util._decorators import Appender, deprecate_kwarg
from pandas.core.dtypes.common import (
ensure_object,
is_categorical_dtype,
is_datetime64_dtype,
)
from pandas import (
Categorical,
DatetimeIndex,
NaT,
Timestamp,
concat,
isna,
to_datetime,
to_timedelta,
)
from pandas.core.frame import DataFrame
from pandas.core.series import Series
from pandas.io.common import BaseIterator, _stringify_path, get_filepath_or_buffer
_version_error = (
"Version of given Stata file is not 104, 105, 108, "
"111 (Stata 7SE), 113 (Stata 8/9), 114 (Stata 10/11), "
"115 (Stata 12), 117 (Stata 13), or 118 (Stata 14)"
)
_statafile_processing_params1 = """\
convert_dates : boolean, defaults to True
Convert date variables to DataFrame time values.
convert_categoricals : boolean, defaults to True
Read value labels and convert columns to Categorical/Factor variables."""
_encoding_params = """\
encoding : string, None or encoding
Encoding used to parse the files. None defaults to latin-1."""
_statafile_processing_params2 = """\
index_col : string, optional, default: None
Column to set as index.
convert_missing : boolean, defaults to False
Flag indicating whether to convert missing values to their Stata
representations. If False, missing values are replaced with nan.
If True, columns containing missing values are returned with
object data types and missing values are represented by
StataMissingValue objects.
preserve_dtypes : boolean, defaults to True
Preserve Stata datatypes. If False, numeric data are upcast to pandas
default types for foreign data (float64 or int64).
columns : list or None
Columns to retain. Columns will be returned in the given order. None
returns all columns.
order_categoricals : boolean, defaults to True
Flag indicating whether converted categorical data are ordered."""
_chunksize_params = """\
chunksize : int, default None
Return StataReader object for iterations, returns chunks with
given number of lines."""
_iterator_params = """\
iterator : boolean, default False
Return StataReader object."""
_read_stata_doc = """
Read Stata file into DataFrame.
Parameters
----------
filepath_or_buffer : str, path object or file-like object
Any valid string path is acceptable. The string could be a URL. Valid
URL schemes include http, ftp, s3, and file. For file URLs, a host is
expected. A local file could be: ``file://localhost/path/to/table.dta``.
If you want to pass in a path object, pandas accepts any ``os.PathLike``.
By file-like object, we refer to objects with a ``read()`` method,
such as a file handler (e.g. via builtin ``open`` function)
or ``StringIO``.
%s
%s
%s
%s
%s
Returns
-------
DataFrame or StataReader
See Also
--------
io.stata.StataReader : Low-level reader for Stata data files.
DataFrame.to_stata: Export Stata data files.
Examples
--------
Read a Stata dta file:
>>> df = pd.read_stata('filename.dta')
Read a Stata dta file in 10,000 line chunks:
>>> itr = pd.read_stata('filename.dta', chunksize=10000)
>>> for chunk in itr:
... do_something(chunk)
""" % (
_statafile_processing_params1,
_encoding_params,
_statafile_processing_params2,
_chunksize_params,
_iterator_params,
)
_data_method_doc = """\
Read observations from Stata file, converting them into a dataframe
.. deprecated::
This is a legacy method. Use `read` in new code.
Parameters
----------
%s
%s
Returns
-------
DataFrame
""" % (
_statafile_processing_params1,
_statafile_processing_params2,
)
_read_method_doc = """\
Reads observations from Stata file, converting them into a dataframe
Parameters
----------
nrows : int
Number of lines to read from data file, if None read whole file.
%s
%s
Returns
-------
DataFrame
""" % (
_statafile_processing_params1,
_statafile_processing_params2,
)
_stata_reader_doc = """\
Class for reading Stata dta files.
Parameters
----------
path_or_buf : path (string), buffer or path object
string, path object (pathlib.Path or py._path.local.LocalPath) or object
implementing a binary read() functions.
.. versionadded:: 0.23.0 support for pathlib, py.path.
%s
%s
%s
%s
""" % (
_statafile_processing_params1,
_statafile_processing_params2,
_encoding_params,
_chunksize_params,
)
@Appender(_read_stata_doc)
@deprecate_kwarg(old_arg_name="encoding", new_arg_name=None)
@deprecate_kwarg(old_arg_name="index", new_arg_name="index_col")
def read_stata(
filepath_or_buffer,
convert_dates=True,
convert_categoricals=True,
encoding=None,
index_col=None,
convert_missing=False,
preserve_dtypes=True,
columns=None,
order_categoricals=True,
chunksize=None,
iterator=False,
):
reader = StataReader(
filepath_or_buffer,
convert_dates=convert_dates,
convert_categoricals=convert_categoricals,
index_col=index_col,
convert_missing=convert_missing,
preserve_dtypes=preserve_dtypes,
columns=columns,
order_categoricals=order_categoricals,
chunksize=chunksize,
)
if iterator or chunksize:
data = reader
else:
try:
data = reader.read()
finally:
reader.close()
return data
_date_formats = ["%tc", "%tC", "%td", "%d", "%tw", "%tm", "%tq", "%th", "%ty"]
stata_epoch = datetime.datetime(1960, 1, 1)
def _stata_elapsed_date_to_datetime_vec(dates, fmt):
"""
Convert from SIF to datetime. http://www.stata.com/help.cgi?datetime
Parameters
----------
dates : Series
The Stata Internal Format date to convert to datetime according to fmt
fmt : str
The format to convert to. Can be, tc, td, tw, tm, tq, th, ty
Returns
Returns
-------
converted : Series
The converted dates
Examples
--------
>>> dates = pd.Series([52])
>>> _stata_elapsed_date_to_datetime_vec(dates , "%tw")
0 1961-01-01
dtype: datetime64[ns]
Notes
-----
datetime/c - tc
milliseconds since 01jan1960 00:00:00.000, assuming 86,400 s/day
datetime/C - tC - NOT IMPLEMENTED
milliseconds since 01jan1960 00:00:00.000, adjusted for leap seconds
date - td
days since 01jan1960 (01jan1960 = 0)
weekly date - tw
weeks since 1960w1
This assumes 52 weeks in a year, then adds 7 * remainder of the weeks.
The datetime value is the start of the week in terms of days in the
year, not ISO calendar weeks.
monthly date - tm
months since 1960m1
quarterly date - tq
quarters since 1960q1
half-yearly date - th
half-years since 1960h1 yearly
date - ty
years since 0000
If you don't have pandas with datetime support, then you can't do
milliseconds accurately.
"""
MIN_YEAR, MAX_YEAR = Timestamp.min.year, Timestamp.max.year
MAX_DAY_DELTA = (Timestamp.max - datetime.datetime(1960, 1, 1)).days
MIN_DAY_DELTA = (Timestamp.min - datetime.datetime(1960, 1, 1)).days
MIN_MS_DELTA = MIN_DAY_DELTA * 24 * 3600 * 1000
MAX_MS_DELTA = MAX_DAY_DELTA * 24 * 3600 * 1000
def convert_year_month_safe(year, month):
"""
Convert year and month to datetimes, using pandas vectorized versions
when the date range falls within the range supported by pandas.
Otherwise it falls back to a slower but more robust method
using datetime.
"""
if year.max() < MAX_YEAR and year.min() > MIN_YEAR:
return to_datetime(100 * year + month, format="%Y%m")
else:
index = getattr(year, "index", None)
return Series(
[datetime.datetime(y, m, 1) for y, m in zip(year, month)], index=index
)
def convert_year_days_safe(year, days):
"""
Converts year (e.g. 1999) and days since the start of the year to a
datetime or datetime64 Series
"""
if year.max() < (MAX_YEAR - 1) and year.min() > MIN_YEAR:
return to_datetime(year, format="%Y") + to_timedelta(days, unit="d")
else:
index = getattr(year, "index", None)
value = [
datetime.datetime(y, 1, 1) + relativedelta(days=int(d))
for y, d in zip(year, days)
]
return Series(value, index=index)
def convert_delta_safe(base, deltas, unit):
"""
Convert base dates and deltas to datetimes, using pandas vectorized
versions if the deltas satisfy restrictions required to be expressed
as dates in pandas.
"""
index = getattr(deltas, "index", None)
if unit == "d":
if deltas.max() > MAX_DAY_DELTA or deltas.min() < MIN_DAY_DELTA:
values = [base + relativedelta(days=int(d)) for d in deltas]
return Series(values, index=index)
elif unit == "ms":
if deltas.max() > MAX_MS_DELTA or deltas.min() < MIN_MS_DELTA:
values = [
base + relativedelta(microseconds=(int(d) * 1000)) for d in deltas
]
return Series(values, index=index)
else:
raise ValueError("format not understood")
base = to_datetime(base)
deltas = to_timedelta(deltas, unit=unit)
return base + deltas
# TODO: If/when pandas supports more than datetime64[ns], this should be
# improved to use correct range, e.g. datetime[Y] for yearly
bad_locs = np.isnan(dates)
has_bad_values = False
if bad_locs.any():
has_bad_values = True
data_col = Series(dates)
data_col[bad_locs] = 1.0 # Replace with NaT
dates = dates.astype(np.int64)
if fmt.startswith(("%tc", "tc")): # Delta ms relative to base
base = stata_epoch
ms = dates
conv_dates = convert_delta_safe(base, ms, "ms")
elif fmt.startswith(("%tC", "tC")):
warnings.warn("Encountered %tC format. Leaving in Stata " "Internal Format.")
conv_dates = Series(dates, dtype=np.object)
if has_bad_values:
conv_dates[bad_locs] = NaT
return conv_dates
# Delta days relative to base
elif fmt.startswith(("%td", "td", "%d", "d")):
base = stata_epoch
days = dates
conv_dates = convert_delta_safe(base, days, "d")
# does not count leap days - 7 days is a week.
# 52nd week may have more than 7 days
elif fmt.startswith(("%tw", "tw")):
year = stata_epoch.year + dates // 52
days = (dates % 52) * 7
conv_dates = convert_year_days_safe(year, days)
elif fmt.startswith(("%tm", "tm")): # Delta months relative to base
year = stata_epoch.year + dates // 12
month = (dates % 12) + 1
conv_dates = convert_year_month_safe(year, month)
elif fmt.startswith(("%tq", "tq")): # Delta quarters relative to base
year = stata_epoch.year + dates // 4
month = (dates % 4) * 3 + 1
conv_dates = convert_year_month_safe(year, month)
elif fmt.startswith(("%th", "th")): # Delta half-years relative to base
year = stata_epoch.year + dates // 2
month = (dates % 2) * 6 + 1
conv_dates = convert_year_month_safe(year, month)
elif fmt.startswith(("%ty", "ty")): # Years -- not delta
year = dates
month = np.ones_like(dates)
conv_dates = convert_year_month_safe(year, month)
else:
raise ValueError("Date fmt {fmt} not understood".format(fmt=fmt))
if has_bad_values: # Restore NaT for bad values
conv_dates[bad_locs] = NaT
return conv_dates
def _datetime_to_stata_elapsed_vec(dates, fmt):
"""
Convert from datetime to SIF. http://www.stata.com/help.cgi?datetime
Parameters
----------
dates : Series
Series or array containing datetime.datetime or datetime64[ns] to
convert to the Stata Internal Format given by fmt
fmt : str
The format to convert to. Can be, tc, td, tw, tm, tq, th, ty
"""
index = dates.index
NS_PER_DAY = 24 * 3600 * 1000 * 1000 * 1000
US_PER_DAY = NS_PER_DAY / 1000
def parse_dates_safe(dates, delta=False, year=False, days=False):
d = {}
if is_datetime64_dtype(dates.values):
if delta:
delta = dates - stata_epoch
d["delta"] = delta.values.astype(np.int64) // 1000 # microseconds
if days or year:
dates = DatetimeIndex(dates)
d["year"], d["month"] = dates.year, dates.month
if days:
days = dates.astype(np.int64) - to_datetime(
d["year"], format="%Y"
).astype(np.int64)
d["days"] = days // NS_PER_DAY
elif infer_dtype(dates, skipna=False) == "datetime":
if delta:
delta = dates.values - stata_epoch
f = lambda x: US_PER_DAY * x.days + 1000000 * x.seconds + x.microseconds
v = np.vectorize(f)
d["delta"] = v(delta)
if year:
year_month = dates.apply(lambda x: 100 * x.year + x.month)
d["year"] = year_month.values // 100
d["month"] = year_month.values - d["year"] * 100
if days:
f = lambda x: (x - datetime.datetime(x.year, 1, 1)).days
v = np.vectorize(f)
d["days"] = v(dates)
else:
raise ValueError(
"Columns containing dates must contain either "
"datetime64, datetime.datetime or null values."
)
return DataFrame(d, index=index)
bad_loc = isna(dates)
index = dates.index
if bad_loc.any():
dates = Series(dates)
if is_datetime64_dtype(dates):
dates[bad_loc] = to_datetime(stata_epoch)
else:
dates[bad_loc] = stata_epoch
if fmt in ["%tc", "tc"]:
d = parse_dates_safe(dates, delta=True)
conv_dates = d.delta / 1000
elif fmt in ["%tC", "tC"]:
warnings.warn("Stata Internal Format tC not supported.")
conv_dates = dates
elif fmt in ["%td", "td"]:
d = parse_dates_safe(dates, delta=True)
conv_dates = d.delta // US_PER_DAY
elif fmt in ["%tw", "tw"]:
d = parse_dates_safe(dates, year=True, days=True)
conv_dates = 52 * (d.year - stata_epoch.year) + d.days // 7
elif fmt in ["%tm", "tm"]:
d = parse_dates_safe(dates, year=True)
conv_dates = 12 * (d.year - stata_epoch.year) + d.month - 1
elif fmt in ["%tq", "tq"]:
d = parse_dates_safe(dates, year=True)
conv_dates = 4 * (d.year - stata_epoch.year) + (d.month - 1) // 3
elif fmt in ["%th", "th"]:
d = parse_dates_safe(dates, year=True)
conv_dates = 2 * (d.year - stata_epoch.year) + (d.month > 6).astype(np.int)
elif fmt in ["%ty", "ty"]:
d = parse_dates_safe(dates, year=True)
conv_dates = d.year
else:
raise ValueError(
"Format {fmt} is not a known Stata date format".format(fmt=fmt)
)
conv_dates = Series(conv_dates, dtype=np.float64)
missing_value = struct.unpack("<d", b"\x00\x00\x00\x00\x00\x00\xe0\x7f")[0]
conv_dates[bad_loc] = missing_value
return Series(conv_dates, index=index)
excessive_string_length_error = """
Fixed width strings in Stata .dta files are limited to 244 (or fewer)
characters. Column '%s' does not satisfy this restriction. Use the
'version=117' parameter to write the newer (Stata 13 and later) format.
"""
class PossiblePrecisionLoss(Warning):
pass
precision_loss_doc = """
Column converted from %s to %s, and some data are outside of the lossless
conversion range. This may result in a loss of precision in the saved data.
"""
class ValueLabelTypeMismatch(Warning):
pass
value_label_mismatch_doc = """
Stata value labels (pandas categories) must be strings. Column {0} contains
non-string labels which will be converted to strings. Please check that the
Stata data file created has not lost information due to duplicate labels.
"""
class InvalidColumnName(Warning):
pass
invalid_name_doc = """
Not all pandas column names were valid Stata variable names.
The following replacements have been made:
{0}
If this is not what you expect, please make sure you have Stata-compliant
column names in your DataFrame (strings only, max 32 characters, only
alphanumerics and underscores, no Stata reserved words)
"""
def _cast_to_stata_types(data):
"""Checks the dtypes of the columns of a pandas DataFrame for
compatibility with the data types and ranges supported by Stata, and
converts if necessary.
Parameters
----------
data : DataFrame
The DataFrame to check and convert
Notes
-----
Numeric columns in Stata must be one of int8, int16, int32, float32 or
float64, with some additional value restrictions. int8 and int16 columns
are checked for violations of the value restrictions and upcast if needed.
int64 data is not usable in Stata, and so it is downcast to int32 whenever
the value are in the int32 range, and sidecast to float64 when larger than
this range. If the int64 values are outside of the range of those
perfectly representable as float64 values, a warning is raised.
bool columns are cast to int8. uint columns are converted to int of the
same size if there is no loss in precision, otherwise are upcast to a
larger type. uint64 is currently not supported since it is concerted to
object in a DataFrame.
"""
ws = ""
# original, if small, if large
conversion_data = (
(np.bool, np.int8, np.int8),
(np.uint8, np.int8, np.int16),
(np.uint16, np.int16, np.int32),
(np.uint32, np.int32, np.int64),
)
float32_max = struct.unpack("<f", b"\xff\xff\xff\x7e")[0]
float64_max = struct.unpack("<d", b"\xff\xff\xff\xff\xff\xff\xdf\x7f")[0]
for col in data:
dtype = data[col].dtype
# Cast from unsupported types to supported types
for c_data in conversion_data:
if dtype == c_data[0]:
if data[col].max() <= np.iinfo(c_data[1]).max:
dtype = c_data[1]
else:
dtype = c_data[2]
if c_data[2] == np.float64: # Warn if necessary
if data[col].max() >= 2 ** 53:
ws = precision_loss_doc % ("uint64", "float64")
data[col] = data[col].astype(dtype)
# Check values and upcast if necessary
if dtype == np.int8:
if data[col].max() > 100 or data[col].min() < -127:
data[col] = data[col].astype(np.int16)
elif dtype == np.int16:
if data[col].max() > 32740 or data[col].min() < -32767:
data[col] = data[col].astype(np.int32)
elif dtype == np.int64:
if data[col].max() <= 2147483620 and data[col].min() >= -2147483647:
data[col] = data[col].astype(np.int32)
else:
data[col] = data[col].astype(np.float64)
if data[col].max() >= 2 ** 53 or data[col].min() <= -2 ** 53:
ws = precision_loss_doc % ("int64", "float64")
elif dtype in (np.float32, np.float64):
value = data[col].max()
if np.isinf(value):
raise ValueError(
"Column {col} has a maximum value of "
"infinity which is outside the range "
"supported by Stata.".format(col=col)
)
if dtype == np.float32 and value > float32_max:
data[col] = data[col].astype(np.float64)
elif dtype == np.float64:
if value > float64_max:
raise ValueError(
"Column {col} has a maximum value "
"({val}) outside the range supported by "
"Stata ({float64_max})".format(
col=col, val=value, float64_max=float64_max
)
)
if ws:
warnings.warn(ws, PossiblePrecisionLoss)
return data
class StataValueLabel:
"""
Parse a categorical column and prepare formatted output
Parameters
----------
value : int8, int16, int32, float32 or float64
The Stata missing value code
Attributes
----------
string : string
String representation of the Stata missing value
value : int8, int16, int32, float32 or float64
The original encoded missing value
Methods
-------
generate_value_label
"""
def __init__(self, catarray):
self.labname = catarray.name
categories = catarray.cat.categories
self.value_labels = list(zip(np.arange(len(categories)), categories))
self.value_labels.sort(key=lambda x: x[0])
self.text_len = np.int32(0)
self.off = []
self.val = []
self.txt = []
self.n = 0
# Compute lengths and setup lists of offsets and labels
for vl in self.value_labels:
category = vl[1]
if not isinstance(category, str):
category = str(category)
warnings.warn(
value_label_mismatch_doc.format(catarray.name),
ValueLabelTypeMismatch,
)
self.off.append(self.text_len)
self.text_len += len(category) + 1 # +1 for the padding
self.val.append(vl[0])
self.txt.append(category)
self.n += 1
if self.text_len > 32000:
raise ValueError(
"Stata value labels for a single variable must "
"have a combined length less than 32,000 "
"characters."
)
# Ensure int32
self.off = np.array(self.off, dtype=np.int32)
self.val = np.array(self.val, dtype=np.int32)
# Total length
self.len = 4 + 4 + 4 * self.n + 4 * self.n + self.text_len
def _encode(self, s):
"""
Python 3 compatibility shim
"""
return s.encode(self._encoding)
def generate_value_label(self, byteorder, encoding):
"""
Parameters
----------
byteorder : str
Byte order of the output
encoding : str
File encoding
Returns
-------
value_label : bytes
Bytes containing the formatted value label
"""
self._encoding = encoding
bio = BytesIO()
null_string = "\x00"
null_byte = b"\x00"
# len
bio.write(struct.pack(byteorder + "i", self.len))
# labname
labname = self._encode(_pad_bytes(self.labname[:32], 33))
bio.write(labname)
# padding - 3 bytes
for i in range(3):
bio.write(struct.pack("c", null_byte))
# value_label_table
# n - int32
bio.write(struct.pack(byteorder + "i", self.n))
# textlen - int32
bio.write(struct.pack(byteorder + "i", self.text_len))
# off - int32 array (n elements)
for offset in self.off:
bio.write(struct.pack(byteorder + "i", offset))
# val - int32 array (n elements)
for value in self.val:
bio.write(struct.pack(byteorder + "i", value))
# txt - Text labels, null terminated
for text in self.txt:
bio.write(self._encode(text + null_string))
bio.seek(0)
return bio.read()
class StataMissingValue:
"""
An observation's missing value.
Parameters
----------
value : int8, int16, int32, float32 or float64
The Stata missing value code
Attributes
----------
string : string
String representation of the Stata missing value
value : int8, int16, int32, float32 or float64
The original encoded missing value
Notes
-----
More information: <http://www.stata.com/help.cgi?missing>
Integer missing values make the code '.', '.a', ..., '.z' to the ranges
101 ... 127 (for int8), 32741 ... 32767 (for int16) and 2147483621 ...
2147483647 (for int32). Missing values for floating point data types are
more complex but the pattern is simple to discern from the following table.
np.float32 missing values (float in Stata)
0000007f .
0008007f .a
0010007f .b
...
00c0007f .x
00c8007f .y
00d0007f .z
np.float64 missing values (double in Stata)
000000000000e07f .
000000000001e07f .a
000000000002e07f .b
...
000000000018e07f .x
000000000019e07f .y
00000000001ae07f .z
"""
# Construct a dictionary of missing values
MISSING_VALUES = {}
bases = (101, 32741, 2147483621)
for b in bases:
# Conversion to long to avoid hash issues on 32 bit platforms #8968
MISSING_VALUES[b] = "."
for i in range(1, 27):
MISSING_VALUES[i + b] = "." + chr(96 + i)
float32_base = b"\x00\x00\x00\x7f"
increment = struct.unpack("<i", b"\x00\x08\x00\x00")[0]
for i in range(27):
value = struct.unpack("<f", float32_base)[0]
MISSING_VALUES[value] = "."
if i > 0:
MISSING_VALUES[value] += chr(96 + i)
int_value = struct.unpack("<i", struct.pack("<f", value))[0] + increment
float32_base = struct.pack("<i", int_value)
float64_base = b"\x00\x00\x00\x00\x00\x00\xe0\x7f"
increment = struct.unpack("q", b"\x00\x00\x00\x00\x00\x01\x00\x00")[0]
for i in range(27):
value = struct.unpack("<d", float64_base)[0]
MISSING_VALUES[value] = "."
if i > 0:
MISSING_VALUES[value] += chr(96 + i)
int_value = struct.unpack("q", struct.pack("<d", value))[0] + increment
float64_base = struct.pack("q", int_value)
BASE_MISSING_VALUES = {
"int8": 101,
"int16": 32741,
"int32": 2147483621,
"float32": struct.unpack("<f", float32_base)[0],
"float64": struct.unpack("<d", float64_base)[0],
}
def __init__(self, value):
self._value = value
# Conversion to int to avoid hash issues on 32 bit platforms #8968
value = int(value) if value < 2147483648 else float(value)
self._str = self.MISSING_VALUES[value]
string = property(
lambda self: self._str,
doc="The Stata representation of the missing value: " "'.', '.a'..'.z'",
)
value = property(
lambda self: self._value, doc="The binary representation of the missing value."
)
def __str__(self):
return self.string
def __repr__(self):
# not perfect :-/
return "{cls}({obj})".format(cls=self.__class__, obj=self)
def __eq__(self, other):
return (
isinstance(other, self.__class__)
and self.string == other.string
and self.value == other.value
)
@classmethod
def get_base_missing_value(cls, dtype):
if dtype == np.int8:
value = cls.BASE_MISSING_VALUES["int8"]
elif dtype == np.int16:
value = cls.BASE_MISSING_VALUES["int16"]
elif dtype == np.int32:
value = cls.BASE_MISSING_VALUES["int32"]
elif dtype == np.float32:
value = cls.BASE_MISSING_VALUES["float32"]
elif dtype == np.float64:
value = cls.BASE_MISSING_VALUES["float64"]
else:
raise ValueError("Unsupported dtype")
return value
class StataParser:
def __init__(self):
# type code.
# --------------------
# str1 1 = 0x01
# str2 2 = 0x02
# ...
# str244 244 = 0xf4
# byte 251 = 0xfb (sic)
# int 252 = 0xfc
# long 253 = 0xfd
# float 254 = 0xfe
# double 255 = 0xff
# --------------------
# NOTE: the byte type seems to be reserved for categorical variables
# with a label, but the underlying variable is -127 to 100
# we're going to drop the label and cast to int
self.DTYPE_MAP = dict(
list(zip(range(1, 245), ["a" + str(i) for i in range(1, 245)]))
+ [
(251, np.int8),
(252, np.int16),
(253, np.int32),
(254, np.float32),
(255, np.float64),
]
)
self.DTYPE_MAP_XML = dict(
[
(32768, np.uint8), # Keys to GSO
(65526, np.float64),
(65527, np.float32),
(65528, np.int32),
(65529, np.int16),
(65530, np.int8),
]
)
self.TYPE_MAP = list(range(251)) + list("bhlfd")
self.TYPE_MAP_XML = dict(
[
# Not really a Q, unclear how to handle byteswap
(32768, "Q"),
(65526, "d"),
(65527, "f"),
(65528, "l"),
(65529, "h"),
(65530, "b"),
]
)
# NOTE: technically, some of these are wrong. there are more numbers
# that can be represented. it's the 27 ABOVE and BELOW the max listed
# numeric data type in [U] 12.2.2 of the 11.2 manual
float32_min = b"\xff\xff\xff\xfe"
float32_max = b"\xff\xff\xff\x7e"
float64_min = b"\xff\xff\xff\xff\xff\xff\xef\xff"
float64_max = b"\xff\xff\xff\xff\xff\xff\xdf\x7f"
self.VALID_RANGE = {
"b": (-127, 100),
"h": (-32767, 32740),
"l": (-2147483647, 2147483620),
"f": (
np.float32(struct.unpack("<f", float32_min)[0]),
np.float32(struct.unpack("<f", float32_max)[0]),
),
"d": (
np.float64(struct.unpack("<d", float64_min)[0]),
np.float64(struct.unpack("<d", float64_max)[0]),
),
}
self.OLD_TYPE_MAPPING = {
98: 251, # byte
105: 252, # int
108: 253, # long
102: 254 # float
# don't know old code for double
}
# These missing values are the generic '.' in Stata, and are used
# to replace nans
self.MISSING_VALUES = {
"b": 101,
"h": 32741,
"l": 2147483621,
"f": np.float32(struct.unpack("<f", b"\x00\x00\x00\x7f")[0]),
"d": np.float64(
struct.unpack("<d", b"\x00\x00\x00\x00\x00\x00\xe0\x7f")[0]
),
}
self.NUMPY_TYPE_MAP = {
"b": "i1",
"h": "i2",
"l": "i4",
"f": "f4",
"d": "f8",
"Q": "u8",
}
# Reserved words cannot be used as variable names
self.RESERVED_WORDS = (
"aggregate",
"array",
"boolean",
"break",
"byte",
"case",
"catch",
"class",
"colvector",
"complex",
"const",
"continue",
"default",
"delegate",
"delete",
"do",
"double",
"else",
"eltypedef",
"end",
"enum",
"explicit",
"export",
"external",
"float",
"for",
"friend",
"function",
"global",
"goto",
"if",
"inline",
"int",
"local",
"long",
"NULL",
"pragma",
"protected",
"quad",
"rowvector",
"short",
"typedef",
"typename",
"virtual",
)
class StataReader(StataParser, BaseIterator):
__doc__ = _stata_reader_doc
@deprecate_kwarg(old_arg_name="encoding", new_arg_name=None)
@deprecate_kwarg(old_arg_name="index", new_arg_name="index_col")
def __init__(
self,
path_or_buf,
convert_dates=True,
convert_categoricals=True,
index_col=None,
convert_missing=False,
preserve_dtypes=True,
columns=None,
order_categoricals=True,
encoding=None,
chunksize=None,
):
super().__init__()
self.col_sizes = ()
# Arguments to the reader (can be temporarily overridden in
# calls to read).
self._convert_dates = convert_dates
self._convert_categoricals = convert_categoricals
self._index_col = index_col
self._convert_missing = convert_missing
self._preserve_dtypes = preserve_dtypes
self._columns = columns
self._order_categoricals = order_categoricals
self._encoding = None
self._chunksize = chunksize
# State variables for the file
self._has_string_data = False
self._missing_values = False
self._can_read_value_labels = False
self._column_selector_set = False
self._value_labels_read = False
self._data_read = False
self._dtype = None
self._lines_read = 0
self._native_byteorder = _set_endianness(sys.byteorder)
path_or_buf = _stringify_path(path_or_buf)
if isinstance(path_or_buf, str):
path_or_buf, encoding, _, should_close = get_filepath_or_buffer(path_or_buf)
if isinstance(path_or_buf, (str, bytes)):
self.path_or_buf = open(path_or_buf, "rb")
else:
# Copy to BytesIO, and ensure no encoding
contents = path_or_buf.read()
self.path_or_buf = BytesIO(contents)
self._read_header()
self._setup_dtype()
def __enter__(self):
""" enter context manager """
return self
def __exit__(self, exc_type, exc_value, traceback):
""" exit context manager """
self.close()
def close(self):
""" close the handle if its open """
try:
self.path_or_buf.close()
except IOError:
pass
def _set_encoding(self):
"""
Set string encoding which depends on file version
"""
if self.format_version < 118:
self._encoding = "latin-1"
else:
self._encoding = "utf-8"
def _read_header(self):
first_char = self.path_or_buf.read(1)
if struct.unpack("c", first_char)[0] == b"<":
self._read_new_header(first_char)
else:
self._read_old_header(first_char)
self.has_string_data = len([x for x in self.typlist if type(x) is int]) > 0
# calculate size of a data record
self.col_sizes = [self._calcsize(typ) for typ in self.typlist]
def _read_new_header(self, first_char):
# The first part of the header is common to 117 and 118.
self.path_or_buf.read(27) # stata_dta><header><release>
self.format_version = int(self.path_or_buf.read(3))
if self.format_version not in [117, 118]:
raise ValueError(_version_error)
self._set_encoding()
self.path_or_buf.read(21) # </release><byteorder>
self.byteorder = self.path_or_buf.read(3) == b"MSF" and ">" or "<"
self.path_or_buf.read(15) # </byteorder><K>
self.nvar = struct.unpack(self.byteorder + "H", self.path_or_buf.read(2))[0]
self.path_or_buf.read(7) # </K><N>
self.nobs = self._get_nobs()
self.path_or_buf.read(11) # </N><label>
self._data_label = self._get_data_label()
self.path_or_buf.read(19) # </label><timestamp>
self.time_stamp = self._get_time_stamp()
self.path_or_buf.read(26) # </timestamp></header><map>
self.path_or_buf.read(8) # 0x0000000000000000
self.path_or_buf.read(8) # position of <map>
self._seek_vartypes = (
struct.unpack(self.byteorder + "q", self.path_or_buf.read(8))[0] + 16
)
self._seek_varnames = (
struct.unpack(self.byteorder + "q", self.path_or_buf.read(8))[0] + 10
)
self._seek_sortlist = (
struct.unpack(self.byteorder + "q", self.path_or_buf.read(8))[0] + 10
)
self._seek_formats = (
struct.unpack(self.byteorder + "q", self.path_or_buf.read(8))[0] + 9
)
self._seek_value_label_names = (
struct.unpack(self.byteorder + "q", self.path_or_buf.read(8))[0] + 19
)
# Requires version-specific treatment
self._seek_variable_labels = self._get_seek_variable_labels()
self.path_or_buf.read(8) # <characteristics>
self.data_location = (
struct.unpack(self.byteorder + "q", self.path_or_buf.read(8))[0] + 6
)
self.seek_strls = (
struct.unpack(self.byteorder + "q", self.path_or_buf.read(8))[0] + 7
)
self.seek_value_labels = (
struct.unpack(self.byteorder + "q", self.path_or_buf.read(8))[0] + 14
)
self.typlist, self.dtyplist = self._get_dtypes(self._seek_vartypes)
self.path_or_buf.seek(self._seek_varnames)
self.varlist = self._get_varlist()
self.path_or_buf.seek(self._seek_sortlist)
self.srtlist = struct.unpack(
self.byteorder + ("h" * (self.nvar + 1)),
self.path_or_buf.read(2 * (self.nvar + 1)),
)[:-1]
self.path_or_buf.seek(self._seek_formats)
self.fmtlist = self._get_fmtlist()
self.path_or_buf.seek(self._seek_value_label_names)
self.lbllist = self._get_lbllist()
self.path_or_buf.seek(self._seek_variable_labels)
self._variable_labels = self._get_variable_labels()
# Get data type information, works for versions 117-118.
def _get_dtypes(self, seek_vartypes):
self.path_or_buf.seek(seek_vartypes)
raw_typlist = [
struct.unpack(self.byteorder + "H", self.path_or_buf.read(2))[0]
for i in range(self.nvar)
]
def f(typ):
if typ <= 2045:
return typ
try:
return self.TYPE_MAP_XML[typ]
except KeyError:
raise ValueError("cannot convert stata types [{0}]".format(typ))
typlist = [f(x) for x in raw_typlist]
def f(typ):
if typ <= 2045:
return str(typ)
try:
return self.DTYPE_MAP_XML[typ]
except KeyError:
raise ValueError("cannot convert stata dtype [{0}]".format(typ))
dtyplist = [f(x) for x in raw_typlist]
return typlist, dtyplist
def _get_varlist(self):
if self.format_version == 117:
b = 33
elif self.format_version == 118:
b = 129
return [self._decode(self.path_or_buf.read(b)) for i in range(self.nvar)]
# Returns the format list
def _get_fmtlist(self):
if self.format_version == 118:
b = 57
elif self.format_version > 113:
b = 49
elif self.format_version > 104:
b = 12
else:
b = 7
return [self._decode(self.path_or_buf.read(b)) for i in range(self.nvar)]
# Returns the label list
def _get_lbllist(self):
if self.format_version >= 118:
b = 129
elif self.format_version > 108:
b = 33
else:
b = 9
return [self._decode(self.path_or_buf.read(b)) for i in range(self.nvar)]
def _get_variable_labels(self):
if self.format_version == 118:
vlblist = [
self._decode(self.path_or_buf.read(321)) for i in range(self.nvar)
]
elif self.format_version > 105:
vlblist = [
self._decode(self.path_or_buf.read(81)) for i in range(self.nvar)
]
else:
vlblist = [
self._decode(self.path_or_buf.read(32)) for i in range(self.nvar)
]
return vlblist
def _get_nobs(self):
if self.format_version == 118:
return struct.unpack(self.byteorder + "Q", self.path_or_buf.read(8))[0]
else:
return struct.unpack(self.byteorder + "I", self.path_or_buf.read(4))[0]
def _get_data_label(self):
if self.format_version == 118:
strlen = struct.unpack(self.byteorder + "H", self.path_or_buf.read(2))[0]
return self._decode(self.path_or_buf.read(strlen))
elif self.format_version == 117:
strlen = struct.unpack("b", self.path_or_buf.read(1))[0]
return self._decode(self.path_or_buf.read(strlen))
elif self.format_version > 105:
return self._decode(self.path_or_buf.read(81))
else:
return self._decode(self.path_or_buf.read(32))
def _get_time_stamp(self):
if self.format_version == 118:
strlen = struct.unpack("b", self.path_or_buf.read(1))[0]
return self.path_or_buf.read(strlen).decode("utf-8")
elif self.format_version == 117:
strlen = struct.unpack("b", self.path_or_buf.read(1))[0]
return self._decode(self.path_or_buf.read(strlen))
elif self.format_version > 104:
return self._decode(self.path_or_buf.read(18))
else:
raise ValueError()
def _get_seek_variable_labels(self):
if self.format_version == 117:
self.path_or_buf.read(8) # <variable_lables>, throw away
# Stata 117 data files do not follow the described format. This is
# a work around that uses the previous label, 33 bytes for each
# variable, 20 for the closing tag and 17 for the opening tag
return self._seek_value_label_names + (33 * self.nvar) + 20 + 17
elif self.format_version == 118:
return struct.unpack(self.byteorder + "q", self.path_or_buf.read(8))[0] + 17
else:
raise ValueError()
def _read_old_header(self, first_char):
self.format_version = struct.unpack("b", first_char)[0]
if self.format_version not in [104, 105, 108, 111, 113, 114, 115]:
raise ValueError(_version_error)
self._set_encoding()
self.byteorder = (
struct.unpack("b", self.path_or_buf.read(1))[0] == 0x1 and ">" or "<"
)
self.filetype = struct.unpack("b", self.path_or_buf.read(1))[0]
self.path_or_buf.read(1) # unused
self.nvar = struct.unpack(self.byteorder + "H", self.path_or_buf.read(2))[0]
self.nobs = self._get_nobs()
self._data_label = self._get_data_label()
self.time_stamp = self._get_time_stamp()
# descriptors
if self.format_version > 108:
typlist = [ord(self.path_or_buf.read(1)) for i in range(self.nvar)]
else:
buf = self.path_or_buf.read(self.nvar)
typlistb = np.frombuffer(buf, dtype=np.uint8)
typlist = []
for tp in typlistb:
if tp in self.OLD_TYPE_MAPPING:
typlist.append(self.OLD_TYPE_MAPPING[tp])
else:
typlist.append(tp - 127) # bytes
try:
self.typlist = [self.TYPE_MAP[typ] for typ in typlist]
except ValueError:
raise ValueError(
"cannot convert stata types [{0}]".format(
",".join(str(x) for x in typlist)
)
)
try:
self.dtyplist = [self.DTYPE_MAP[typ] for typ in typlist]
except ValueError:
raise ValueError(
"cannot convert stata dtypes [{0}]".format(
",".join(str(x) for x in typlist)
)
)
if self.format_version > 108:
self.varlist = [
self._decode(self.path_or_buf.read(33)) for i in range(self.nvar)
]
else:
self.varlist = [
self._decode(self.path_or_buf.read(9)) for i in range(self.nvar)
]
self.srtlist = struct.unpack(
self.byteorder + ("h" * (self.nvar + 1)),
self.path_or_buf.read(2 * (self.nvar + 1)),
)[:-1]
self.fmtlist = self._get_fmtlist()
self.lbllist = self._get_lbllist()
self._variable_labels = self._get_variable_labels()
# ignore expansion fields (Format 105 and later)
# When reading, read five bytes; the last four bytes now tell you
# the size of the next read, which you discard. You then continue
# like this until you read 5 bytes of zeros.
if self.format_version > 104:
while True:
data_type = struct.unpack(
self.byteorder + "b", self.path_or_buf.read(1)
)[0]
if self.format_version > 108:
data_len = struct.unpack(
self.byteorder + "i", self.path_or_buf.read(4)
)[0]
else:
data_len = struct.unpack(
self.byteorder + "h", self.path_or_buf.read(2)
)[0]
if data_type == 0:
break
self.path_or_buf.read(data_len)
# necessary data to continue parsing
self.data_location = self.path_or_buf.tell()
def _setup_dtype(self):
"""Map between numpy and state dtypes"""
if self._dtype is not None:
return self._dtype
dtype = [] # Convert struct data types to numpy data type
for i, typ in enumerate(self.typlist):
if typ in self.NUMPY_TYPE_MAP:
dtype.append(("s" + str(i), self.byteorder + self.NUMPY_TYPE_MAP[typ]))
else:
dtype.append(("s" + str(i), "S" + str(typ)))
dtype = np.dtype(dtype)
self._dtype = dtype
return self._dtype
def _calcsize(self, fmt):
return type(fmt) is int and fmt or struct.calcsize(self.byteorder + fmt)
def _decode(self, s):
# have bytes not strings, so must decode
s = s.partition(b"\0")[0]
try:
return s.decode(self._encoding)
except UnicodeDecodeError:
# GH 25960, fallback to handle incorrect format produced when 117
# files are converted to 118 files in Stata
msg = """
One or more strings in the dta file could not be decoded using {encoding}, and
so the fallback encoding of latin-1 is being used. This can happen when a file
has been incorrectly encoded by Stata or some other software. You should verify
the string values returned are correct."""
warnings.warn(msg.format(encoding=self._encoding), UnicodeWarning)
return s.decode("latin-1")
def _read_value_labels(self):
if self._value_labels_read:
# Don't read twice
return
if self.format_version <= 108:
# Value labels are not supported in version 108 and earlier.
self._value_labels_read = True
self.value_label_dict = dict()
return
if self.format_version >= 117:
self.path_or_buf.seek(self.seek_value_labels)
else:
offset = self.nobs * self._dtype.itemsize
self.path_or_buf.seek(self.data_location + offset)
self._value_labels_read = True
self.value_label_dict = dict()
while True:
if self.format_version >= 117:
if self.path_or_buf.read(5) == b"</val": # <lbl>
break # end of value label table
slength = self.path_or_buf.read(4)
if not slength:
break # end of value label table (format < 117)
if self.format_version <= 117:
labname = self._decode(self.path_or_buf.read(33))
else:
labname = self._decode(self.path_or_buf.read(129))
self.path_or_buf.read(3) # padding
n = struct.unpack(self.byteorder + "I", self.path_or_buf.read(4))[0]
txtlen = struct.unpack(self.byteorder + "I", self.path_or_buf.read(4))[0]
off = np.frombuffer(
self.path_or_buf.read(4 * n), dtype=self.byteorder + "i4", count=n
)
val = np.frombuffer(
self.path_or_buf.read(4 * n), dtype=self.byteorder + "i4", count=n
)
ii = np.argsort(off)
off = off[ii]
val = val[ii]
txt = self.path_or_buf.read(txtlen)
self.value_label_dict[labname] = dict()
for i in range(n):
end = off[i + 1] if i < n - 1 else txtlen
self.value_label_dict[labname][val[i]] = self._decode(txt[off[i] : end])
if self.format_version >= 117:
self.path_or_buf.read(6) # </lbl>
self._value_labels_read = True
def _read_strls(self):
self.path_or_buf.seek(self.seek_strls)
# Wrap v_o in a string to allow uint64 values as keys on 32bit OS
self.GSO = {"0": ""}
while True:
if self.path_or_buf.read(3) != b"GSO":
break
if self.format_version == 117:
v_o = struct.unpack(self.byteorder + "Q", self.path_or_buf.read(8))[0]
else:
buf = self.path_or_buf.read(12)
# Only tested on little endian file on little endian machine.
if self.byteorder == "<":
buf = buf[0:2] + buf[4:10]
else:
buf = buf[0:2] + buf[6:]
v_o = struct.unpack("Q", buf)[0]
typ = struct.unpack("B", self.path_or_buf.read(1))[0]
length = struct.unpack(self.byteorder + "I", self.path_or_buf.read(4))[0]
va = self.path_or_buf.read(length)
if typ == 130:
va = va[0:-1].decode(self._encoding)
# Wrap v_o in a string to allow uint64 values as keys on 32bit OS
self.GSO[str(v_o)] = va
# legacy
@Appender(_data_method_doc)
def data(self, **kwargs):
warnings.warn("'data' is deprecated, use 'read' instead")
if self._data_read:
raise Exception("Data has already been read.")
self._data_read = True
return self.read(None, **kwargs)
def __next__(self):
return self.read(nrows=self._chunksize or 1)
def get_chunk(self, size=None):
"""
Reads lines from Stata file and returns as dataframe
Parameters
----------
size : int, defaults to None
Number of lines to read. If None, reads whole file.
Returns
-------
DataFrame
"""
if size is None:
size = self._chunksize
return self.read(nrows=size)
@Appender(_read_method_doc)
@deprecate_kwarg(old_arg_name="index", new_arg_name="index_col")
def read(
self,
nrows=None,
convert_dates=None,
convert_categoricals=None,
index_col=None,
convert_missing=None,
preserve_dtypes=None,
columns=None,
order_categoricals=None,
):
# Handle empty file or chunk. If reading incrementally raise
# StopIteration. If reading the whole thing return an empty
# data frame.
if (self.nobs == 0) and (nrows is None):
self._can_read_value_labels = True
self._data_read = True
self.close()
return DataFrame(columns=self.varlist)
# Handle options
if convert_dates is None:
convert_dates = self._convert_dates
if convert_categoricals is None:
convert_categoricals = self._convert_categoricals
if convert_missing is None:
convert_missing = self._convert_missing
if preserve_dtypes is None:
preserve_dtypes = self._preserve_dtypes
if columns is None:
columns = self._columns
if order_categoricals is None:
order_categoricals = self._order_categoricals
if index_col is None:
index_col = self._index_col
if nrows is None:
nrows = self.nobs
if (self.format_version >= 117) and (not self._value_labels_read):
self._can_read_value_labels = True
self._read_strls()
# Read data
dtype = self._dtype
max_read_len = (self.nobs - self._lines_read) * dtype.itemsize
read_len = nrows * dtype.itemsize
read_len = min(read_len, max_read_len)
if read_len <= 0:
# Iterator has finished, should never be here unless
# we are reading the file incrementally
if convert_categoricals:
self._read_value_labels()
self.close()
raise StopIteration
offset = self._lines_read * dtype.itemsize
self.path_or_buf.seek(self.data_location + offset)
read_lines = min(nrows, self.nobs - self._lines_read)
data = np.frombuffer(
self.path_or_buf.read(read_len), dtype=dtype, count=read_lines
)
self._lines_read += read_lines
if self._lines_read == self.nobs:
self._can_read_value_labels = True
self._data_read = True
# if necessary, swap the byte order to native here
if self.byteorder != self._native_byteorder:
data = data.byteswap().newbyteorder()
if convert_categoricals:
self._read_value_labels()
if len(data) == 0:
data = DataFrame(columns=self.varlist)
else:
data = DataFrame.from_records(data)
data.columns = self.varlist
# If index is not specified, use actual row number rather than
# restarting at 0 for each chunk.
if index_col is None:
ix = np.arange(self._lines_read - read_lines, self._lines_read)
data = data.set_index(ix)
if columns is not None:
try:
data = self._do_select_columns(data, columns)
except ValueError:
self.close()
raise
# Decode strings
for col, typ in zip(data, self.typlist):
if type(typ) is int:
data[col] = data[col].apply(self._decode, convert_dtype=True)
data = self._insert_strls(data)
cols_ = np.where(self.dtyplist)[0]
# Convert columns (if needed) to match input type
ix = data.index
requires_type_conversion = False
data_formatted = []
for i in cols_:
if self.dtyplist[i] is not None:
col = data.columns[i]
dtype = data[col].dtype
if dtype != np.dtype(object) and dtype != self.dtyplist[i]:
requires_type_conversion = True
data_formatted.append(
(col, Series(data[col], ix, self.dtyplist[i]))
)
else:
data_formatted.append((col, data[col]))
if requires_type_conversion:
data = DataFrame.from_dict(OrderedDict(data_formatted))
del data_formatted
data = self._do_convert_missing(data, convert_missing)
if convert_dates:
def any_startswith(x: str) -> bool:
return any(x.startswith(fmt) for fmt in _date_formats)
cols = np.where([any_startswith(x) for x in self.fmtlist])[0]
for i in cols:
col = data.columns[i]
try:
data[col] = _stata_elapsed_date_to_datetime_vec(
data[col], self.fmtlist[i]
)
except ValueError:
self.close()
raise
if convert_categoricals and self.format_version > 108:
data = self._do_convert_categoricals(
data, self.value_label_dict, self.lbllist, order_categoricals
)
if not preserve_dtypes:
retyped_data = []
convert = False
for col in data:
dtype = data[col].dtype
if dtype in (np.float16, np.float32):
dtype = np.float64
convert = True
elif dtype in (np.int8, np.int16, np.int32):
dtype = np.int64
convert = True
retyped_data.append((col, data[col].astype(dtype)))
if convert:
data = DataFrame.from_dict(OrderedDict(retyped_data))
if index_col is not None:
data = data.set_index(data.pop(index_col))
return data
def _do_convert_missing(self, data, convert_missing):
# Check for missing values, and replace if found
replacements = {}
for i, colname in enumerate(data):
fmt = self.typlist[i]
if fmt not in self.VALID_RANGE:
continue
nmin, nmax = self.VALID_RANGE[fmt]
series = data[colname]
missing = np.logical_or(series < nmin, series > nmax)
if not missing.any():
continue
if convert_missing: # Replacement follows Stata notation
missing_loc = np.argwhere(missing._ndarray_values)
umissing, umissing_loc = np.unique(series[missing], return_inverse=True)
replacement = Series(series, dtype=np.object)
for j, um in enumerate(umissing):
missing_value = StataMissingValue(um)
loc = missing_loc[umissing_loc == j]
replacement.iloc[loc] = missing_value
else: # All replacements are identical
dtype = series.dtype
if dtype not in (np.float32, np.float64):
dtype = np.float64
replacement = Series(series, dtype=dtype)
replacement[missing] = np.nan
replacements[colname] = replacement
if replacements:
columns = data.columns
replacements = DataFrame(replacements)
data = concat([data.drop(replacements.columns, 1), replacements], 1)
data = data[columns]
return data
def _insert_strls(self, data):
if not hasattr(self, "GSO") or len(self.GSO) == 0:
return data
for i, typ in enumerate(self.typlist):
if typ != "Q":
continue
# Wrap v_o in a string to allow uint64 values as keys on 32bit OS
data.iloc[:, i] = [self.GSO[str(k)] for k in data.iloc[:, i]]
return data
def _do_select_columns(self, data, columns):
if not self._column_selector_set:
column_set = set(columns)
if len(column_set) != len(columns):
raise ValueError("columns contains duplicate entries")
unmatched = column_set.difference(data.columns)
if unmatched:
raise ValueError(
"The following columns were not found in the "
"Stata data set: " + ", ".join(list(unmatched))
)
# Copy information for retained columns for later processing
dtyplist = []
typlist = []
fmtlist = []
lbllist = []
for col in columns:
i = data.columns.get_loc(col)
dtyplist.append(self.dtyplist[i])
typlist.append(self.typlist[i])
fmtlist.append(self.fmtlist[i])
lbllist.append(self.lbllist[i])
self.dtyplist = dtyplist
self.typlist = typlist
self.fmtlist = fmtlist
self.lbllist = lbllist
self._column_selector_set = True
return data[columns]
def _do_convert_categoricals(
self, data, value_label_dict, lbllist, order_categoricals
):
"""
Converts categorical columns to Categorical type.
"""
value_labels = list(value_label_dict.keys())
cat_converted_data = []
for col, label in zip(data, lbllist):
if label in value_labels:
# Explicit call with ordered=True
cat_data = Categorical(data[col], ordered=order_categoricals)
categories = []
for category in cat_data.categories:
if category in value_label_dict[label]:
categories.append(value_label_dict[label][category])
else:
categories.append(category) # Partially labeled
try:
cat_data.categories = categories
except ValueError:
vc = Series(categories).value_counts()
repeats = list(vc.index[vc > 1])
repeats = "-" * 80 + "\n" + "\n".join(repeats)
# GH 25772
msg = """
Value labels for column {col} are not unique. These cannot be converted to
pandas categoricals.
Either read the file with `convert_categoricals` set to False or use the
low level interface in `StataReader` to separately read the values and the
value_labels.
The repeated labels are:
{repeats}
"""
raise ValueError(msg.format(col=col, repeats=repeats))
# TODO: is the next line needed above in the data(...) method?
cat_data = Series(cat_data, index=data.index)
cat_converted_data.append((col, cat_data))
else:
cat_converted_data.append((col, data[col]))
data = DataFrame.from_dict(OrderedDict(cat_converted_data))
return data
@property
def data_label(self):
"""
Return data label of Stata file.
"""
return self._data_label
def variable_labels(self):
"""
Return variable labels as a dict, associating each variable name
with corresponding label.
Returns
-------
dict
"""
return dict(zip(self.varlist, self._variable_labels))
def value_labels(self):
"""
Return a dict, associating each variable name a dict, associating
each value its corresponding label.
Returns
-------
dict
"""
if not self._value_labels_read:
self._read_value_labels()
return self.value_label_dict
def _open_file_binary_write(fname):
"""
Open a binary file or no-op if file-like.
Parameters
----------
fname : string path, path object or buffer
Returns
-------
file : file-like object
File object supporting write
own : bool
True if the file was created, otherwise False
"""
if hasattr(fname, "write"):
# if 'b' not in fname.mode:
return fname, False
return open(fname, "wb"), True
def _set_endianness(endianness):
if endianness.lower() in ["<", "little"]:
return "<"
elif endianness.lower() in [">", "big"]:
return ">"
else: # pragma : no cover
raise ValueError("Endianness {endian} not understood".format(endian=endianness))
def _pad_bytes(name, length):
"""
Take a char string and pads it with null bytes until it's length chars.
"""
return name + "\x00" * (length - len(name))
def _convert_datetime_to_stata_type(fmt):
"""
Convert from one of the stata date formats to a type in TYPE_MAP.
"""
if fmt in [
"tc",
"%tc",
"td",
"%td",
"tw",
"%tw",
"tm",
"%tm",
"tq",
"%tq",
"th",
"%th",
"ty",
"%ty",
]:
return np.float64 # Stata expects doubles for SIFs
else:
raise NotImplementedError("Format {fmt} not implemented".format(fmt=fmt))
def _maybe_convert_to_int_keys(convert_dates, varlist):
new_dict = {}
for key in convert_dates:
if not convert_dates[key].startswith("%"): # make sure proper fmts
convert_dates[key] = "%" + convert_dates[key]
if key in varlist:
new_dict.update({varlist.index(key): convert_dates[key]})
else:
if not isinstance(key, int):
raise ValueError("convert_dates key must be a " "column or an integer")
new_dict.update({key: convert_dates[key]})
return new_dict
def _dtype_to_stata_type(dtype, column):
"""
Convert dtype types to stata types. Returns the byte of the given ordinal.
See TYPE_MAP and comments for an explanation. This is also explained in
the dta spec.
1 - 244 are strings of this length
Pandas Stata
251 - for int8 byte
252 - for int16 int
253 - for int32 long
254 - for float32 float
255 - for double double
If there are dates to convert, then dtype will already have the correct
type inserted.
"""
# TODO: expand to handle datetime to integer conversion
if dtype.type == np.object_: # try to coerce it to the biggest string
# not memory efficient, what else could we
# do?
itemsize = max_len_string_array(ensure_object(column.values))
return max(itemsize, 1)
elif dtype == np.float64:
return 255
elif dtype == np.float32:
return 254
elif dtype == np.int32:
return 253
elif dtype == np.int16:
return 252
elif dtype == np.int8:
return 251
else: # pragma : no cover
raise NotImplementedError(
"Data type {dtype} not supported.".format(dtype=dtype)
)
def _dtype_to_default_stata_fmt(dtype, column, dta_version=114, force_strl=False):
"""
Map numpy dtype to stata's default format for this type. Not terribly
important since users can change this in Stata. Semantics are
object -> "%DDs" where DD is the length of the string. If not a string,
raise ValueError
float64 -> "%10.0g"
float32 -> "%9.0g"
int64 -> "%9.0g"
int32 -> "%12.0g"
int16 -> "%8.0g"
int8 -> "%8.0g"
strl -> "%9s"
"""
# TODO: Refactor to combine type with format
# TODO: expand this to handle a default datetime format?
if dta_version < 117:
max_str_len = 244
else:
max_str_len = 2045
if force_strl:
return "%9s"
if dtype.type == np.object_:
inferred_dtype = infer_dtype(column, skipna=True)
if not (inferred_dtype in ("string", "unicode") or len(column) == 0):
raise ValueError(
"Column `{col}` cannot be exported.\n\nOnly "
"string-like object arrays containing all "
"strings or a mix of strings and None can be "
"exported. Object arrays containing only null "
"values are prohibited. Other object types"
"cannot be exported and must first be converted "
"to one of the supported "
"types.".format(col=column.name)
)
itemsize = max_len_string_array(ensure_object(column.values))
if itemsize > max_str_len:
if dta_version >= 117:
return "%9s"
else:
raise ValueError(excessive_string_length_error % column.name)
return "%" + str(max(itemsize, 1)) + "s"
elif dtype == np.float64:
return "%10.0g"
elif dtype == np.float32:
return "%9.0g"
elif dtype == np.int32:
return "%12.0g"
elif dtype == np.int8 or dtype == np.int16:
return "%8.0g"
else: # pragma : no cover
raise NotImplementedError(
"Data type {dtype} not supported.".format(dtype=dtype)
)
class StataWriter(StataParser):
"""
A class for writing Stata binary dta files
Parameters
----------
fname : path (string), buffer or path object
string, path object (pathlib.Path or py._path.local.LocalPath) or
object implementing a binary write() functions. If using a buffer
then the buffer will not be automatically closed after the file
is written.
.. versionadded:: 0.23.0 support for pathlib, py.path.
data : DataFrame
Input to save
convert_dates : dict
Dictionary mapping columns containing datetime types to stata internal
format to use when writing the dates. Options are 'tc', 'td', 'tm',
'tw', 'th', 'tq', 'ty'. Column can be either an integer or a name.
Datetime columns that do not have a conversion type specified will be
converted to 'tc'. Raises NotImplementedError if a datetime column has
timezone information
write_index : bool
Write the index to Stata dataset.
encoding : str
Default is latin-1. Only latin-1 and ascii are supported.
byteorder : str
Can be ">", "<", "little", or "big". default is `sys.byteorder`
time_stamp : datetime
A datetime to use as file creation date. Default is the current time
data_label : str
A label for the data set. Must be 80 characters or smaller.
variable_labels : dict
Dictionary containing columns as keys and variable labels as values.
Each label must be 80 characters or smaller.
.. versionadded:: 0.19.0
Returns
-------
writer : StataWriter instance
The StataWriter instance has a write_file method, which will
write the file to the given `fname`.
Raises
------
NotImplementedError
* If datetimes contain timezone information
ValueError
* Columns listed in convert_dates are neither datetime64[ns]
or datetime.datetime
* Column dtype is not representable in Stata
* Column listed in convert_dates is not in DataFrame
* Categorical label contains more than 32,000 characters
Examples
--------
>>> data = pd.DataFrame([[1.0, 1]], columns=['a', 'b'])
>>> writer = StataWriter('./data_file.dta', data)
>>> writer.write_file()
Or with dates
>>> from datetime import datetime
>>> data = pd.DataFrame([[datetime(2000,1,1)]], columns=['date'])
>>> writer = StataWriter('./date_data_file.dta', data, {'date' : 'tw'})
>>> writer.write_file()
"""
_max_string_length = 244
@deprecate_kwarg(old_arg_name="encoding", new_arg_name=None)
def __init__(
self,
fname,
data,
convert_dates=None,
write_index=True,
encoding="latin-1",
byteorder=None,
time_stamp=None,
data_label=None,
variable_labels=None,
):
super().__init__()
self._convert_dates = {} if convert_dates is None else convert_dates
self._write_index = write_index
self._encoding = "latin-1"
self._time_stamp = time_stamp
self._data_label = data_label
self._variable_labels = variable_labels
self._own_file = True
# attach nobs, nvars, data, varlist, typlist
self._prepare_pandas(data)
if byteorder is None:
byteorder = sys.byteorder
self._byteorder = _set_endianness(byteorder)
self._fname = _stringify_path(fname)
self.type_converters = {253: np.int32, 252: np.int16, 251: np.int8}
self._converted_names = {}
def _write(self, to_write):
"""
Helper to call encode before writing to file for Python 3 compat.
"""
self._file.write(to_write.encode(self._encoding or self._default_encoding))
def _prepare_categoricals(self, data):
"""Check for categorical columns, retain categorical information for
Stata file and convert categorical data to int"""
is_cat = [is_categorical_dtype(data[col]) for col in data]
self._is_col_cat = is_cat
self._value_labels = []
if not any(is_cat):
return data
get_base_missing_value = StataMissingValue.get_base_missing_value
data_formatted = []
for col, col_is_cat in zip(data, is_cat):
if col_is_cat:
self._value_labels.append(StataValueLabel(data[col]))
dtype = data[col].cat.codes.dtype
if dtype == np.int64:
raise ValueError(
"It is not possible to export "
"int64-based categorical data to Stata."
)
values = data[col].cat.codes.values.copy()
# Upcast if needed so that correct missing values can be set
if values.max() >= get_base_missing_value(dtype):
if dtype == np.int8:
dtype = np.int16
elif dtype == np.int16:
dtype = np.int32
else:
dtype = np.float64
values = np.array(values, dtype=dtype)
# Replace missing values with Stata missing value for type
values[values == -1] = get_base_missing_value(dtype)
data_formatted.append((col, values))
else:
data_formatted.append((col, data[col]))
return DataFrame.from_dict(OrderedDict(data_formatted))
def _replace_nans(self, data):
# return data
"""Checks floating point data columns for nans, and replaces these with
the generic Stata for missing value (.)"""
for c in data:
dtype = data[c].dtype
if dtype in (np.float32, np.float64):
if dtype == np.float32:
replacement = self.MISSING_VALUES["f"]
else:
replacement = self.MISSING_VALUES["d"]
data[c] = data[c].fillna(replacement)
return data
def _update_strl_names(self):
"""No-op, forward compatibility"""
pass
def _check_column_names(self, data):
"""
Checks column names to ensure that they are valid Stata column names.
This includes checks for:
* Non-string names
* Stata keywords
* Variables that start with numbers
* Variables with names that are too long
When an illegal variable name is detected, it is converted, and if
dates are exported, the variable name is propagated to the date
conversion dictionary
"""
converted_names = {}
columns = list(data.columns)
original_columns = columns[:]
duplicate_var_id = 0
for j, name in enumerate(columns):
orig_name = name
if not isinstance(name, str):
name = str(name)
for c in name:
if (
(c < "A" or c > "Z")
and (c < "a" or c > "z")
and (c < "0" or c > "9")
and c != "_"
):
name = name.replace(c, "_")
# Variable name must not be a reserved word
if name in self.RESERVED_WORDS:
name = "_" + name
# Variable name may not start with a number
if name[0] >= "0" and name[0] <= "9":
name = "_" + name
name = name[: min(len(name), 32)]
if not name == orig_name:
# check for duplicates
while columns.count(name) > 0:
# prepend ascending number to avoid duplicates
name = "_" + str(duplicate_var_id) + name
name = name[: min(len(name), 32)]
duplicate_var_id += 1
converted_names[orig_name] = name
columns[j] = name
data.columns = columns
# Check date conversion, and fix key if needed
if self._convert_dates:
for c, o in zip(columns, original_columns):
if c != o:
self._convert_dates[c] = self._convert_dates[o]
del self._convert_dates[o]
if converted_names:
conversion_warning = []
for orig_name, name in converted_names.items():
# need to possibly encode the orig name if its unicode
try:
orig_name = orig_name.encode("utf-8")
except (UnicodeDecodeError, AttributeError):
pass
msg = "{0} -> {1}".format(orig_name, name)
conversion_warning.append(msg)
ws = invalid_name_doc.format("\n ".join(conversion_warning))
warnings.warn(ws, InvalidColumnName)
self._converted_names = converted_names
self._update_strl_names()
return data
def _set_formats_and_types(self, data, dtypes):
self.typlist = []
self.fmtlist = []
for col, dtype in dtypes.items():
self.fmtlist.append(_dtype_to_default_stata_fmt(dtype, data[col]))
self.typlist.append(_dtype_to_stata_type(dtype, data[col]))
def _prepare_pandas(self, data):
# NOTE: we might need a different API / class for pandas objects so
# we can set different semantics - handle this with a PR to pandas.io
data = data.copy()
if self._write_index:
data = data.reset_index()
# Ensure column names are strings
data = self._check_column_names(data)
# Check columns for compatibility with stata, upcast if necessary
# Raise if outside the supported range
data = _cast_to_stata_types(data)
# Replace NaNs with Stata missing values
data = self._replace_nans(data)
# Convert categoricals to int data, and strip labels
data = self._prepare_categoricals(data)
self.nobs, self.nvar = data.shape
self.data = data
self.varlist = data.columns.tolist()
dtypes = data.dtypes
# Ensure all date columns are converted
for col in data:
if col in self._convert_dates:
continue
if is_datetime64_dtype(data[col]):
self._convert_dates[col] = "tc"
self._convert_dates = _maybe_convert_to_int_keys(
self._convert_dates, self.varlist
)
for key in self._convert_dates:
new_type = _convert_datetime_to_stata_type(self._convert_dates[key])
dtypes[key] = np.dtype(new_type)
self._set_formats_and_types(data, dtypes)
# set the given format for the datetime cols
if self._convert_dates is not None:
for key in self._convert_dates:
self.fmtlist[key] = self._convert_dates[key]
def write_file(self):
self._file, self._own_file = _open_file_binary_write(self._fname)
try:
self._write_header(time_stamp=self._time_stamp, data_label=self._data_label)
self._write_map()
self._write_variable_types()
self._write_varnames()
self._write_sortlist()
self._write_formats()
self._write_value_label_names()
self._write_variable_labels()
self._write_expansion_fields()
self._write_characteristics()
self._prepare_data()
self._write_data()
self._write_strls()
self._write_value_labels()
self._write_file_close_tag()
self._write_map()
except Exception as exc:
self._close()
try:
if self._own_file:
os.unlink(self._fname)
except Exception:
warnings.warn(
"This save was not successful but {0} could not "
"be deleted. This file is not "
"valid.".format(self._fname),
ResourceWarning,
)
raise exc
else:
self._close()
def _close(self):
"""
Close the file if it was created by the writer.
If a buffer or file-like object was passed in, for example a GzipFile,
then leave this file open for the caller to close. In either case,
attempt to flush the file contents to ensure they are written to disk
(if supported)
"""
# Some file-like objects might not support flush
try:
self._file.flush()
except AttributeError:
pass
if self._own_file:
self._file.close()
def _write_map(self):
"""No-op, future compatibility"""
pass
def _write_file_close_tag(self):
"""No-op, future compatibility"""
pass
def _write_characteristics(self):
"""No-op, future compatibility"""
pass
def _write_strls(self):
"""No-op, future compatibility"""
pass
def _write_expansion_fields(self):
"""Write 5 zeros for expansion fields"""
self._write(_pad_bytes("", 5))
def _write_value_labels(self):
for vl in self._value_labels:
self._file.write(vl.generate_value_label(self._byteorder, self._encoding))
def _write_header(self, data_label=None, time_stamp=None):
byteorder = self._byteorder
# ds_format - just use 114
self._file.write(struct.pack("b", 114))
# byteorder
self._write(byteorder == ">" and "\x01" or "\x02")
# filetype
self._write("\x01")
# unused
self._write("\x00")
# number of vars, 2 bytes
self._file.write(struct.pack(byteorder + "h", self.nvar)[:2])
# number of obs, 4 bytes
self._file.write(struct.pack(byteorder + "i", self.nobs)[:4])
# data label 81 bytes, char, null terminated
if data_label is None:
self._file.write(self._null_terminate(_pad_bytes("", 80)))
else:
self._file.write(self._null_terminate(_pad_bytes(data_label[:80], 80)))
# time stamp, 18 bytes, char, null terminated
# format dd Mon yyyy hh:mm
if time_stamp is None:
time_stamp = datetime.datetime.now()
elif not isinstance(time_stamp, datetime.datetime):
raise ValueError("time_stamp should be datetime type")
# GH #13856
# Avoid locale-specific month conversion
months = [
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec",
]
month_lookup = {i + 1: month for i, month in enumerate(months)}
ts = (
time_stamp.strftime("%d ")
+ month_lookup[time_stamp.month]
+ time_stamp.strftime(" %Y %H:%M")
)
self._file.write(self._null_terminate(ts))
def _write_variable_types(self):
for typ in self.typlist:
self._file.write(struct.pack("B", typ))
def _write_varnames(self):
# varlist names are checked by _check_column_names
# varlist, requires null terminated
for name in self.varlist:
name = self._null_terminate(name, True)
name = _pad_bytes(name[:32], 33)
self._write(name)
def _write_sortlist(self):
# srtlist, 2*(nvar+1), int array, encoded by byteorder
srtlist = _pad_bytes("", 2 * (self.nvar + 1))
self._write(srtlist)
def _write_formats(self):
# fmtlist, 49*nvar, char array
for fmt in self.fmtlist:
self._write(_pad_bytes(fmt, 49))
def _write_value_label_names(self):
# lbllist, 33*nvar, char array
for i in range(self.nvar):
# Use variable name when categorical
if self._is_col_cat[i]:
name = self.varlist[i]
name = self._null_terminate(name, True)
name = _pad_bytes(name[:32], 33)
self._write(name)
else: # Default is empty label
self._write(_pad_bytes("", 33))
def _write_variable_labels(self):
# Missing labels are 80 blank characters plus null termination
blank = _pad_bytes("", 81)
if self._variable_labels is None:
for i in range(self.nvar):
self._write(blank)
return
for col in self.data:
if col in self._variable_labels:
label = self._variable_labels[col]
if len(label) > 80:
raise ValueError(
"Variable labels must be 80 characters " "or fewer"
)
is_latin1 = all(ord(c) < 256 for c in label)
if not is_latin1:
raise ValueError(
"Variable labels must contain only "
"characters that can be encoded in "
"Latin-1"
)
self._write(_pad_bytes(label, 81))
else:
self._write(blank)
def _convert_strls(self, data):
"""No-op, future compatibility"""
return data
def _prepare_data(self):
data = self.data
typlist = self.typlist
convert_dates = self._convert_dates
# 1. Convert dates
if self._convert_dates is not None:
for i, col in enumerate(data):
if i in convert_dates:
data[col] = _datetime_to_stata_elapsed_vec(
data[col], self.fmtlist[i]
)
# 2. Convert strls
data = self._convert_strls(data)
# 3. Convert bad string data to '' and pad to correct length
dtypes = {}
native_byteorder = self._byteorder == _set_endianness(sys.byteorder)
for i, col in enumerate(data):
typ = typlist[i]
if typ <= self._max_string_length:
data[col] = data[col].fillna("").apply(_pad_bytes, args=(typ,))
stype = "S{type}".format(type=typ)
dtypes[col] = stype
data[col] = data[col].str.encode(self._encoding).astype(stype)
else:
dtype = data[col].dtype
if not native_byteorder:
dtype = dtype.newbyteorder(self._byteorder)
dtypes[col] = dtype
self.data = data.to_records(index=False, column_dtypes=dtypes)
def _write_data(self):
data = self.data
self._file.write(data.tobytes())
def _null_terminate(self, s, as_string=False):
null_byte = "\x00"
s += null_byte
if not as_string:
s = s.encode(self._encoding)
return s
def _dtype_to_stata_type_117(dtype, column, force_strl):
"""
Converts dtype types to stata types. Returns the byte of the given ordinal.
See TYPE_MAP and comments for an explanation. This is also explained in
the dta spec.
1 - 2045 are strings of this length
Pandas Stata
32768 - for object strL
65526 - for int8 byte
65527 - for int16 int
65528 - for int32 long
65529 - for float32 float
65530 - for double double
If there are dates to convert, then dtype will already have the correct
type inserted.
"""
# TODO: expand to handle datetime to integer conversion
if force_strl:
return 32768
if dtype.type == np.object_: # try to coerce it to the biggest string
# not memory efficient, what else could we
# do?
itemsize = max_len_string_array(ensure_object(column.values))
itemsize = max(itemsize, 1)
if itemsize <= 2045:
return itemsize
return 32768
elif dtype == np.float64:
return 65526
elif dtype == np.float32:
return 65527
elif dtype == np.int32:
return 65528
elif dtype == np.int16:
return 65529
elif dtype == np.int8:
return 65530
else: # pragma : no cover
raise NotImplementedError("Data type %s not supported." % dtype)
def _pad_bytes_new(name, length):
"""
Takes a bytes instance and pads it with null bytes until it's length chars.
"""
if isinstance(name, str):
name = bytes(name, "utf-8")
return name + b"\x00" * (length - len(name))
class StataStrLWriter:
"""
Converter for Stata StrLs
Stata StrLs map 8 byte values to strings which are stored using a
dictionary-like format where strings are keyed to two values.
Parameters
----------
df : DataFrame
DataFrame to convert
columns : list
List of columns names to convert to StrL
version : int, optional
dta version. Currently supports 117, 118 and 119
byteorder : str, optional
Can be ">", "<", "little", or "big". default is `sys.byteorder`
Notes
-----
Supports creation of the StrL block of a dta file for dta versions
117, 118 and 119. These differ in how the GSO is stored. 118 and
119 store the GSO lookup value as a uint32 and a uint64, while 117
uses two uint32s. 118 and 119 also encode all strings as unicode
which is required by the format. 117 uses 'latin-1' a fixed width
encoding that extends the 7-bit ascii table with an additional 128
characters.
"""
def __init__(self, df, columns, version=117, byteorder=None):
if version not in (117, 118, 119):
raise ValueError("Only dta versions 117, 118 and 119 supported")
self._dta_ver = version
self.df = df
self.columns = columns
self._gso_table = OrderedDict((("", (0, 0)),))
if byteorder is None:
byteorder = sys.byteorder
self._byteorder = _set_endianness(byteorder)
gso_v_type = "I" # uint32
gso_o_type = "Q" # uint64
self._encoding = "utf-8"
if version == 117:
o_size = 4
gso_o_type = "I" # 117 used uint32
self._encoding = "latin-1"
elif version == 118:
o_size = 6
else: # version == 119
o_size = 5
self._o_offet = 2 ** (8 * (8 - o_size))
self._gso_o_type = gso_o_type
self._gso_v_type = gso_v_type
def _convert_key(self, key):
v, o = key
return v + self._o_offet * o
def generate_table(self):
"""
Generates the GSO lookup table for the DataFRame
Returns
-------
gso_table : OrderedDict
Ordered dictionary using the string found as keys
and their lookup position (v,o) as values
gso_df : DataFrame
DataFrame where strl columns have been converted to
(v,o) values
Notes
-----
Modifies the DataFrame in-place.
The DataFrame returned encodes the (v,o) values as uint64s. The
encoding depends on teh dta version, and can be expressed as
enc = v + o * 2 ** (o_size * 8)
so that v is stored in the lower bits and o is in the upper
bits. o_size is
* 117: 4
* 118: 6
* 119: 5
"""
gso_table = self._gso_table
gso_df = self.df
columns = list(gso_df.columns)
selected = gso_df[self.columns]
col_index = [(col, columns.index(col)) for col in self.columns]
keys = np.empty(selected.shape, dtype=np.uint64)
for o, (idx, row) in enumerate(selected.iterrows()):
for j, (col, v) in enumerate(col_index):
val = row[col]
# Allow columns with mixed str and None (GH 23633)
val = "" if val is None else val
key = gso_table.get(val, None)
if key is None:
# Stata prefers human numbers
key = (v + 1, o + 1)
gso_table[val] = key
keys[o, j] = self._convert_key(key)
for i, col in enumerate(self.columns):
gso_df[col] = keys[:, i]
return gso_table, gso_df
def _encode(self, s):
"""
Python 3 compatibility shim
"""
return s.encode(self._encoding)
def generate_blob(self, gso_table):
"""
Generates the binary blob of GSOs that is written to the dta file.
Parameters
----------
gso_table : OrderedDict
Ordered dictionary (str, vo)
Returns
-------
gso : bytes
Binary content of dta file to be placed between strl tags
Notes
-----
Output format depends on dta version. 117 uses two uint32s to
express v and o while 118+ uses a uint32 for v and a uint64 for o.
"""
# Format information
# Length includes null term
# 117
# GSOvvvvooootllllxxxxxxxxxxxxxxx...x
# 3 u4 u4 u1 u4 string + null term
#
# 118, 119
# GSOvvvvooooooootllllxxxxxxxxxxxxxxx...x
# 3 u4 u8 u1 u4 string + null term
bio = BytesIO()
gso = bytes("GSO", "ascii")
gso_type = struct.pack(self._byteorder + "B", 130)
null = struct.pack(self._byteorder + "B", 0)
v_type = self._byteorder + self._gso_v_type
o_type = self._byteorder + self._gso_o_type
len_type = self._byteorder + "I"
for strl, vo in gso_table.items():
if vo == (0, 0):
continue
v, o = vo
# GSO
bio.write(gso)
# vvvv
bio.write(struct.pack(v_type, v))
# oooo / oooooooo
bio.write(struct.pack(o_type, o))
# t
bio.write(gso_type)
# llll
utf8_string = bytes(strl, "utf-8")
bio.write(struct.pack(len_type, len(utf8_string) + 1))
# xxx...xxx
bio.write(utf8_string)
bio.write(null)
bio.seek(0)
return bio.read()
class StataWriter117(StataWriter):
"""
A class for writing Stata binary dta files in Stata 13 format (117)
.. versionadded:: 0.23.0
Parameters
----------
fname : path (string), buffer or path object
string, path object (pathlib.Path or py._path.local.LocalPath) or
object implementing a binary write() functions. If using a buffer
then the buffer will not be automatically closed after the file
is written.
data : DataFrame
Input to save
convert_dates : dict
Dictionary mapping columns containing datetime types to stata internal
format to use when writing the dates. Options are 'tc', 'td', 'tm',
'tw', 'th', 'tq', 'ty'. Column can be either an integer or a name.
Datetime columns that do not have a conversion type specified will be
converted to 'tc'. Raises NotImplementedError if a datetime column has
timezone information
write_index : bool
Write the index to Stata dataset.
encoding : str
Default is latin-1. Only latin-1 and ascii are supported.
byteorder : str
Can be ">", "<", "little", or "big". default is `sys.byteorder`
time_stamp : datetime
A datetime to use as file creation date. Default is the current time
data_label : str
A label for the data set. Must be 80 characters or smaller.
variable_labels : dict
Dictionary containing columns as keys and variable labels as values.
Each label must be 80 characters or smaller.
convert_strl : list
List of columns names to convert to Stata StrL format. Columns with
more than 2045 characters are automatically written as StrL.
Smaller columns can be converted by including the column name. Using
StrLs can reduce output file size when strings are longer than 8
characters, and either frequently repeated or sparse.
Returns
-------
writer : StataWriter117 instance
The StataWriter117 instance has a write_file method, which will
write the file to the given `fname`.
Raises
------
NotImplementedError
* If datetimes contain timezone information
ValueError
* Columns listed in convert_dates are neither datetime64[ns]
or datetime.datetime
* Column dtype is not representable in Stata
* Column listed in convert_dates is not in DataFrame
* Categorical label contains more than 32,000 characters
Examples
--------
>>> from pandas.io.stata import StataWriter117
>>> data = pd.DataFrame([[1.0, 1, 'a']], columns=['a', 'b', 'c'])
>>> writer = StataWriter117('./data_file.dta', data)
>>> writer.write_file()
Or with long strings stored in strl format
>>> data = pd.DataFrame([['A relatively long string'], [''], ['']],
... columns=['strls'])
>>> writer = StataWriter117('./data_file_with_long_strings.dta', data,
... convert_strl=['strls'])
>>> writer.write_file()
"""
_max_string_length = 2045
@deprecate_kwarg(old_arg_name="encoding", new_arg_name=None)
def __init__(
self,
fname,
data,
convert_dates=None,
write_index=True,
encoding="latin-1",
byteorder=None,
time_stamp=None,
data_label=None,
variable_labels=None,
convert_strl=None,
):
# Shallow copy since convert_strl might be modified later
self._convert_strl = [] if convert_strl is None else convert_strl[:]
super().__init__(
fname,
data,
convert_dates,
write_index,
byteorder=byteorder,
time_stamp=time_stamp,
data_label=data_label,
variable_labels=variable_labels,
)
self._map = None
self._strl_blob = None
@staticmethod
def _tag(val, tag):
"""Surround val with <tag></tag>"""
if isinstance(val, str):
val = bytes(val, "utf-8")
return bytes("<" + tag + ">", "utf-8") + val + bytes("</" + tag + ">", "utf-8")
def _update_map(self, tag):
"""Update map location for tag with file position"""
self._map[tag] = self._file.tell()
def _write_header(self, data_label=None, time_stamp=None):
"""Write the file header"""
byteorder = self._byteorder
self._file.write(bytes("<stata_dta>", "utf-8"))
bio = BytesIO()
# ds_format - 117
bio.write(self._tag(bytes("117", "utf-8"), "release"))
# byteorder
bio.write(self._tag(byteorder == ">" and "MSF" or "LSF", "byteorder"))
# number of vars, 2 bytes
assert self.nvar < 2 ** 16
bio.write(self._tag(struct.pack(byteorder + "H", self.nvar), "K"))
# number of obs, 4 bytes
bio.write(self._tag(struct.pack(byteorder + "I", self.nobs), "N"))
# data label 81 bytes, char, null terminated
label = data_label[:80] if data_label is not None else ""
label_len = struct.pack(byteorder + "B", len(label))
label = label_len + bytes(label, "utf-8")
bio.write(self._tag(label, "label"))
# time stamp, 18 bytes, char, null terminated
# format dd Mon yyyy hh:mm
if time_stamp is None:
time_stamp = datetime.datetime.now()
elif not isinstance(time_stamp, datetime.datetime):
raise ValueError("time_stamp should be datetime type")
# Avoid locale-specific month conversion
months = [
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec",
]
month_lookup = {i + 1: month for i, month in enumerate(months)}
ts = (
time_stamp.strftime("%d ")
+ month_lookup[time_stamp.month]
+ time_stamp.strftime(" %Y %H:%M")
)
# '\x11' added due to inspection of Stata file
ts = b"\x11" + bytes(ts, "utf8")
bio.write(self._tag(ts, "timestamp"))
bio.seek(0)
self._file.write(self._tag(bio.read(), "header"))
def _write_map(self):
"""Called twice during file write. The first populates the values in
the map with 0s. The second call writes the final map locations when
all blocks have been written."""
if self._map is None:
self._map = OrderedDict(
(
("stata_data", 0),
("map", self._file.tell()),
("variable_types", 0),
("varnames", 0),
("sortlist", 0),
("formats", 0),
("value_label_names", 0),
("variable_labels", 0),
("characteristics", 0),
("data", 0),
("strls", 0),
("value_labels", 0),
("stata_data_close", 0),
("end-of-file", 0),
)
)
# Move to start of map
self._file.seek(self._map["map"])
bio = BytesIO()
for val in self._map.values():
bio.write(struct.pack(self._byteorder + "Q", val))
bio.seek(0)
self._file.write(self._tag(bio.read(), "map"))
def _write_variable_types(self):
self._update_map("variable_types")
bio = BytesIO()
for typ in self.typlist:
bio.write(struct.pack(self._byteorder + "H", typ))
bio.seek(0)
self._file.write(self._tag(bio.read(), "variable_types"))
def _write_varnames(self):
self._update_map("varnames")
bio = BytesIO()
for name in self.varlist:
name = self._null_terminate(name, True)
name = _pad_bytes_new(name[:32], 33)
bio.write(name)
bio.seek(0)
self._file.write(self._tag(bio.read(), "varnames"))
def _write_sortlist(self):
self._update_map("sortlist")
self._file.write(self._tag(b"\x00\00" * (self.nvar + 1), "sortlist"))
def _write_formats(self):
self._update_map("formats")
bio = BytesIO()
for fmt in self.fmtlist:
bio.write(_pad_bytes_new(fmt, 49))
bio.seek(0)
self._file.write(self._tag(bio.read(), "formats"))
def _write_value_label_names(self):
self._update_map("value_label_names")
bio = BytesIO()
for i in range(self.nvar):
# Use variable name when categorical
name = "" # default name
if self._is_col_cat[i]:
name = self.varlist[i]
name = self._null_terminate(name, True)
name = _pad_bytes_new(name[:32], 33)
bio.write(name)
bio.seek(0)
self._file.write(self._tag(bio.read(), "value_label_names"))
def _write_variable_labels(self):
# Missing labels are 80 blank characters plus null termination
self._update_map("variable_labels")
bio = BytesIO()
blank = _pad_bytes_new("", 81)
if self._variable_labels is None:
for _ in range(self.nvar):
bio.write(blank)
bio.seek(0)
self._file.write(self._tag(bio.read(), "variable_labels"))
return
for col in self.data:
if col in self._variable_labels:
label = self._variable_labels[col]
if len(label) > 80:
raise ValueError(
"Variable labels must be 80 characters " "or fewer"
)
is_latin1 = all(ord(c) < 256 for c in label)
if not is_latin1:
raise ValueError(
"Variable labels must contain only "
"characters that can be encoded in "
"Latin-1"
)
bio.write(_pad_bytes_new(label, 81))
else:
bio.write(blank)
bio.seek(0)
self._file.write(self._tag(bio.read(), "variable_labels"))
def _write_characteristics(self):
self._update_map("characteristics")
self._file.write(self._tag(b"", "characteristics"))
def _write_data(self):
self._update_map("data")
data = self.data
self._file.write(b"<data>")
self._file.write(data.tobytes())
self._file.write(b"</data>")
def _write_strls(self):
self._update_map("strls")
strls = b""
if self._strl_blob is not None:
strls = self._strl_blob
self._file.write(self._tag(strls, "strls"))
def _write_expansion_fields(self):
"""No-op in dta 117+"""
pass
def _write_value_labels(self):
self._update_map("value_labels")
bio = BytesIO()
for vl in self._value_labels:
lab = vl.generate_value_label(self._byteorder, self._encoding)
lab = self._tag(lab, "lbl")
bio.write(lab)
bio.seek(0)
self._file.write(self._tag(bio.read(), "value_labels"))
def _write_file_close_tag(self):
self._update_map("stata_data_close")
self._file.write(bytes("</stata_dta>", "utf-8"))
self._update_map("end-of-file")
def _update_strl_names(self):
"""Update column names for conversion to strl if they might have been
changed to comply with Stata naming rules"""
# Update convert_strl if names changed
for orig, new in self._converted_names.items():
if orig in self._convert_strl:
idx = self._convert_strl.index(orig)
self._convert_strl[idx] = new
def _convert_strls(self, data):
"""Convert columns to StrLs if either very large or in the
convert_strl variable"""
convert_cols = [
col
for i, col in enumerate(data)
if self.typlist[i] == 32768 or col in self._convert_strl
]
if convert_cols:
ssw = StataStrLWriter(data, convert_cols)
tab, new_data = ssw.generate_table()
data = new_data
self._strl_blob = ssw.generate_blob(tab)
return data
def _set_formats_and_types(self, data, dtypes):
self.typlist = []
self.fmtlist = []
for col, dtype in dtypes.items():
force_strl = col in self._convert_strl
fmt = _dtype_to_default_stata_fmt(
dtype, data[col], dta_version=117, force_strl=force_strl
)
self.fmtlist.append(fmt)
self.typlist.append(_dtype_to_stata_type_117(dtype, data[col], force_strl))
| apache-2.0 |
JelteF/statistics | 4/pca.py | 1 | 2669 | import numpy as np
from scipy.misc import imread
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import os.path
from pylatex import Subsection, Plt, Figure
n = 256
m = 25
def compare(img, pos, mean_vec, d, U, k, show=False):
x, y = pos
detail = img[x:x+m, y:y+m].reshape((m*m, 1))
det_zm = detail - mean_vec
y_zm = U.T.dot(det_zm)
y_zm_k = y_zm[:k]
det_zm_k = U[:, :k].dot(y_zm_k)
det_k = det_zm_k + mean_vec
if show:
plt.subplot(2, 1, 1)
plt.imshow(detail.reshape((m, m)), cmap=cm.Greys_r)
plt.subplot(2, 1, 2)
plt.imshow(det_k.reshape((m, m)), cmap=cm.Greys_r)
plt.show()
return det_k
def sorted_eig(mat):
d, U = np.linalg.eig(mat)
si = np.argsort(d)[-1::-1]
d = d[si]
U = U[:, si]
return d, U
def main():
img = imread('trui.png')
if not os.path.isfile('d.npy'):
sum_mat = np.zeros((m*m, m*m), np.int)
mean_sum_vec = np.zeros((m*m, 1), np.int)
for i in range(n-m+1):
for j in range(n-m+1):
detail = img[i:i+m, j:j+m].reshape((m*m, 1))
sum_mat += detail * detail.T
mean_sum_vec += detail
mean_vec = mean_sum_vec / float(n*n)
mean_mat = n * mean_vec * mean_vec.T
S = (sum_mat - mean_mat) / ((m*m)-1)
d, U = sorted_eig(S)
np.save('d', d)
np.save('U', U)
np.save('mean_vec', mean_vec)
else:
d = np.load('d.npy')
U = np.load('U.npy')
mean_vec = np.load('mean_vec.npy')
plt.bar(range(6), abs(d[:6]))
# plt.show()
with open('scree.tex', 'w') as f:
plot = Plt(position='htbp')
plot.add_plot(plt)
plot.add_caption('Scree diagram')
plot.dump(f)
sec = Subsection('Gereconstrueerde foto\'s')
with sec.create(Figure(position='htbp')) as fig:
fig.add_image('trui.png')
fig.add_caption('Origineel')
for k in [0, 1, 3, 5, 7, 10, 20, 30, 50, 80, 120, 170,
220, 300, 370, 450, 520, 590, 625]:
reconstructed = np.zeros((n, n))
for i in range(0, 232, 25):
for j in range(0, 232, 25):
subimg = compare(img, (i, j), mean_vec, d, U, k)
reconstructed[i:i+25, j:j+25] = subimg.reshape((25, 25))
plt.imshow(reconstructed, cmap=cm.Greys_r)
plt.title('k = ' + str(k))
# plt.show()
with sec.create(Plt(position='htbp')) as plot:
plot.add_plot(plt)
plot.add_caption('k = ' + str(k))
with open('images.tex', 'w') as f:
sec.dump(f)
if __name__ == '__main__':
main()
| mit |
Obus/scikit-learn | examples/linear_model/plot_multi_task_lasso_support.py | 249 | 2211 | #!/usr/bin/env python
"""
=============================================
Joint feature selection with multi-task Lasso
=============================================
The multi-task lasso allows to fit multiple regression problems
jointly enforcing the selected features to be the same across
tasks. This example simulates sequential measurements, each task
is a time instant, and the relevant features vary in amplitude
over time while being the same. The multi-task lasso imposes that
features that are selected at one time point are select for all time
point. This makes feature selection by the Lasso more stable.
"""
print(__doc__)
# Author: Alexandre Gramfort <[email protected]>
# License: BSD 3 clause
import matplotlib.pyplot as plt
import numpy as np
from sklearn.linear_model import MultiTaskLasso, Lasso
rng = np.random.RandomState(42)
# Generate some 2D coefficients with sine waves with random frequency and phase
n_samples, n_features, n_tasks = 100, 30, 40
n_relevant_features = 5
coef = np.zeros((n_tasks, n_features))
times = np.linspace(0, 2 * np.pi, n_tasks)
for k in range(n_relevant_features):
coef[:, k] = np.sin((1. + rng.randn(1)) * times + 3 * rng.randn(1))
X = rng.randn(n_samples, n_features)
Y = np.dot(X, coef.T) + rng.randn(n_samples, n_tasks)
coef_lasso_ = np.array([Lasso(alpha=0.5).fit(X, y).coef_ for y in Y.T])
coef_multi_task_lasso_ = MultiTaskLasso(alpha=1.).fit(X, Y).coef_
###############################################################################
# Plot support and time series
fig = plt.figure(figsize=(8, 5))
plt.subplot(1, 2, 1)
plt.spy(coef_lasso_)
plt.xlabel('Feature')
plt.ylabel('Time (or Task)')
plt.text(10, 5, 'Lasso')
plt.subplot(1, 2, 2)
plt.spy(coef_multi_task_lasso_)
plt.xlabel('Feature')
plt.ylabel('Time (or Task)')
plt.text(10, 5, 'MultiTaskLasso')
fig.suptitle('Coefficient non-zero location')
feature_to_plot = 0
plt.figure()
plt.plot(coef[:, feature_to_plot], 'k', label='Ground truth')
plt.plot(coef_lasso_[:, feature_to_plot], 'g', label='Lasso')
plt.plot(coef_multi_task_lasso_[:, feature_to_plot],
'r', label='MultiTaskLasso')
plt.legend(loc='upper center')
plt.axis('tight')
plt.ylim([-1.1, 1.1])
plt.show()
| bsd-3-clause |
broesamle/servo | tests/heartbeats/process_logs.py | 139 | 16143 | #!/usr/bin/env python
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
import argparse
import matplotlib.pyplot as plt
import numpy as np
import os
from os import path
import sys
import warnings
HB_LOG_IDX_START_TIME = 7
HB_LOG_IDX_END_TIME = HB_LOG_IDX_START_TIME + 1
HB_LOG_IDX_START_ENERGY = 14
HB_LOG_IDX_END_ENERGY = HB_LOG_IDX_START_ENERGY + 1
ENERGY_PROFILER_NAME = 'ApplicationHeartbeat'
SUMMARY_OUTPUT = "summary.txt"
SUMMARY_TIME_IDX = 8
SUMMARY_ENERGY_IDX = SUMMARY_TIME_IDX + 1
SUMMARY_POWER_IDX = SUMMARY_ENERGY_IDX + 1
def autolabel(rects, ax):
"""Attach some text labels.
"""
for rect in rects:
ax.text(rect.get_x() + rect.get_width() / 2., 1.05 * rect.get_height(), '', ha='center', va='bottom')
def plot_raw_totals(config, plot_data, max_time, max_time_std, max_energy, max_energy_std, output_dir, normalize):
"""Plot the raw totals for a configuration.
Keyword arguments:
config -- configuration name
plot_data -- (profiler name, total_time, total_time_std, total_energy, total_energy_std)
max_time, max_time_std, max_energy, max_energy_std -- single values
normalize -- True/False
"""
plot_data = sorted(plot_data)
keys = [p for (p, tt, tts, te, tes) in plot_data]
total_times = [tt for (p, tt, tts, te, tes) in plot_data]
total_times_std = [tts for (p, tt, tts, te, tes) in plot_data]
total_energies = [te for (p, tt, tts, te, tes) in plot_data]
total_energies_std = [tes for (p, tt, tts, te, tes) in plot_data]
fig, ax1 = plt.subplots()
ind = np.arange(len(keys)) # the x locations for the groups
width = 0.35 # the width of the bars
# add some text for labels, title and axes ticks
ax1.set_title('Time/Energy Data for Configuration ' + config)
ax1.set_xticks(ind + width)
ax1.set_xticklabels(keys, rotation=45)
fig.set_tight_layout(True)
fig.set_size_inches(len(plot_data) / 1.5, 8)
ax2 = ax1.twinx()
# Normalize
if normalize:
total_times_std /= np.sum(total_times)
total_times /= np.sum(total_times)
total_energies_std /= np.sum(total_energies)
total_energies /= np.sum(total_energies)
ax1.set_ylabel('Time (Normalized)')
ax2.set_ylabel('Energy (Normalized)')
else:
# set time in us instead of ns
total_times_std /= np.array(1000000.0)
total_times /= np.array(1000000.0)
total_energies_std /= np.array(1000000.0)
total_energies /= np.array(1000000.0)
ax1.set_ylabel('Time (ms)')
ax2.set_ylabel('Energy (Joules)')
rects1 = ax1.bar(ind, total_times, width, color='r', yerr=total_times_std)
rects2 = ax2.bar(ind + width, total_energies, width, color='y', yerr=total_energies_std)
ax1.legend([rects1[0], rects2[0]], ['Time', 'Energy'])
# set axis
x1, x2, y1, y2 = plt.axis()
if normalize:
ax1.set_ylim(ymin=0, ymax=1)
ax2.set_ylim(ymin=0, ymax=1)
else:
ax1.set_ylim(ymin=0, ymax=((max_time + max_time_std) * 1.25 / 1000000.0))
ax2.set_ylim(ymin=0, ymax=((max_energy + max_energy_std) * 1.25 / 1000000.0))
autolabel(rects1, ax1)
autolabel(rects2, ax2)
# plt.show()
plt.savefig(path.join(output_dir, config + ".png"))
plt.close(fig)
def create_raw_total_data(config_data):
"""Get the raw data to plot for a configuration
Return: [(profiler, time_mean, time_stddev, energy_mean, energy_stddev)]
Keyword arguments:
config_data -- (trial, trial_data)
"""
# We can't assume that the same number of heartbeats are always issued across trials
# key: profiler name; value: list of timing sums for each trial
profiler_total_times = {}
# key: profiler name; value: list of energy sums for each trial
profiler_total_energies = {}
for (t, td) in config_data:
for (profiler, ts, te, es, ee) in td:
# sum the total times and energies for each profiler in this trial
total_time = np.sum(te - ts)
total_energy = np.sum(ee - es)
# add to list to be averaged later
time_list = profiler_total_times.get(profiler, [])
time_list.append(total_time)
profiler_total_times[profiler] = time_list
energy_list = profiler_total_energies.get(profiler, [])
energy_list.append(total_energy)
profiler_total_energies[profiler] = energy_list
# Get mean and stddev for time and energy totals
return [(profiler,
np.mean(profiler_total_times[profiler]),
np.std(profiler_total_times[profiler]),
np.mean(profiler_total_energies[profiler]),
np.std(profiler_total_energies[profiler]))
for profiler in profiler_total_times.keys()]
def plot_all_raw_totals(config_list, output_dir):
"""Plot column charts of the raw total time/energy spent in each profiler category.
Keyword arguments:
config_list -- [(config, result of process_config_dir(...))]
output_dir -- where to write plots to
"""
raw_total_norm_out_dir = path.join(output_dir, 'raw_totals_normalized')
os.makedirs(raw_total_norm_out_dir)
raw_total_out_dir = path.join(output_dir, 'raw_totals')
os.makedirs(raw_total_out_dir)
# (name, (profiler, (time_mean, time_stddev, energy_mean, energy_stddev)))
raw_totals_data = [(config, create_raw_total_data(config_data)) for (config, config_data) in config_list]
mean_times = []
mean_times_std = []
mean_energies = []
mean_energies_std = []
for profiler_tup in [config_tup[1] for config_tup in raw_totals_data]:
for (p, tt, tts, te, tes) in profiler_tup:
mean_times.append(tt)
mean_times_std.append(tts)
mean_energies.append(te)
mean_energies_std.append(tes)
# get consistent max time/energy values across plots
max_t = np.max(mean_times)
max_t_std = np.max(mean_times_std)
max_e = np.max(mean_energies)
max_e_std = np.max(mean_energies_std)
[plot_raw_totals(data[0], data[1], max_t, max_t_std, max_e, max_e_std, raw_total_norm_out_dir, True)
for data in raw_totals_data]
[plot_raw_totals(data[0], data[1], max_t, max_t_std, max_e, max_e_std, raw_total_out_dir, False)
for data in raw_totals_data]
def plot_trial_time_series(config, trial, trial_data, max_end_time, max_power, output_dir):
"""Plot time series for a single trial.
Keyword arguments:
config -- the config name
trial -- the trial name
trial_data -- [(profiler, [start times], [end times], [start energies], [end energies])]
max_end_time -- single value to use as max X axis value (for consistency across trials)
output_dir -- the output directory
"""
# TODO: Some profilers may have parallel tasks - need to identify this on plots
max_end_time = max_end_time / 1000000.0
trial_data = sorted(trial_data)
fig, ax1 = plt.subplots()
keys = [p for (p, ts, te, es, ee) in trial_data]
# add some text for labels, title and axes ticks
ax1.set_title('Profiler Activity for ' + config + ', ' + trial)
ax1.set_xlabel('Time (ms)')
ax1.grid(True)
width = 8 # the width of the bars
ax1.set_yticks(10 * np.arange(1, len(keys) + 2))
ax1.set_yticklabels(keys)
ax1.set_ylim(ymin=0, ymax=((len(trial_data) + 1) * 10))
ax1.set_xlim(xmin=0, xmax=max_end_time)
fig.set_tight_layout(True)
fig.set_size_inches(16, len(trial_data) / 3)
i = 10
for (p, ts, te, es, ee) in trial_data:
xranges = [(ts[j] / 1000000.0, (te[j] - ts[j]) / 1000000.0) for j in xrange(len(ts))]
ax1.broken_barh(xranges, (i - 0.5 * width, width))
i += 10
# place a vbar at the final time for this trial
last_profiler_times = map(np.nanmax, filter(lambda x: len(x) > 0, [te for (p, ts, te, es, ee) in trial_data]))
plt.axvline(np.max(last_profiler_times) / 1000000.0, color='black')
power_times = []
power_values = []
for (p, ts, te, es, ee) in trial_data:
if p == ENERGY_PROFILER_NAME:
power_times = te / 1000000.0
power_values = (ee - es) / ((te - ts) / 1000.0)
ax2 = ax1.twinx()
ax2.set_xlim(xmin=0, xmax=max_end_time)
ax2.set_ylim(ymin=0, ymax=max_power)
ax2.set_ylabel('Power (Watts)')
ax2.plot(power_times, power_values, color='r')
# plt.show()
plt.savefig(path.join(output_dir, "ts_" + config + "_" + trial + ".png"))
plt.close(fig)
def hb_energy_times_to_power(es, ee, ts, te):
"""Compute power from start and end energy and times.
Return: power values
"""
return (ee - es) / ((te - ts) / 1000.0)
def plot_all_time_series(config_list, output_dir):
"""Plot column charts of the raw total time/energy spent in each profiler category.
Keyword arguments:
config_list -- [(config, result of process_config_dir(...))]
output_dir -- where to write plots to
"""
time_series_out_dir = path.join(output_dir, 'time_series')
os.makedirs(time_series_out_dir)
max_end_times = []
max_power_values = []
for (c, cd) in config_list:
for (t, td) in cd:
trial_max_end_times = map(np.nanmax, filter(lambda x: len(x) > 0, [te for (p, ts, te, es, ee) in td]))
max_end_times.append(np.nanmax(trial_max_end_times))
for (p, ts, te, es, ee) in td:
# We only care about the energy profiler (others aren't reliable for instant power anyway)
if p == ENERGY_PROFILER_NAME and len(te) > 0:
max_power_values.append(np.nanmax(hb_energy_times_to_power(es, ee, ts, te)))
max_time = np.nanmax(max_end_times)
max_power = np.nanmax(np.array(max_power_values)) * 1.2 # leave a little space at the top
for (config, config_data) in config_list:
[plot_trial_time_series(config, trial, trial_data, max_time, max_power, time_series_out_dir)
for (trial, trial_data) in config_data]
def read_heartbeat_log(profiler_hb_log):
"""Read a heartbeat log file.
Return: (profiler name, [start times], [end times], [start energies], [end energies], [instant powers])
Keyword arguments:
profiler_hb_log -- the file to read
"""
with warnings.catch_warnings():
try:
warnings.simplefilter("ignore")
time_start, time_end, energy_start, energy_end = \
np.loadtxt(profiler_hb_log,
dtype=np.dtype('uint64'),
skiprows=1,
usecols=(HB_LOG_IDX_START_TIME,
HB_LOG_IDX_END_TIME,
HB_LOG_IDX_START_ENERGY,
HB_LOG_IDX_END_ENERGY),
unpack=True,
ndmin=1)
except ValueError:
time_start, time_end, energy_start, energy_end = [], [], [], []
name = path.split(profiler_hb_log)[1].split('-')[1].split('.')[0]
return (name,
np.atleast_1d(time_start),
np.atleast_1d(time_end),
np.atleast_1d(energy_start),
np.atleast_1d(energy_end))
def process_trial_dir(trial_dir):
"""Process trial directory.
Return: [(profiler name, [start times], [end times], [start energies], [end energies])]
Time and energy are normalized to 0 start values.
Keyword arguments:
trial_dir -- the directory for this trial
"""
log_data = map(lambda h: read_heartbeat_log(path.join(trial_dir, h)),
filter(lambda f: f.endswith(".log"), os.listdir(trial_dir)))
# Find the earliest timestamps and energy readings
min_t = np.nanmin(map(np.nanmin, filter(lambda x: len(x) > 0, [ts for (profiler, ts, te, es, ee) in log_data])))
min_e = np.nanmin(map(np.nanmin, filter(lambda x: len(x) > 0, [es for (profiler, ts, te, es, ee) in log_data])))
# Normalize timing/energy data to start values of 0
return [(profiler, ts - min_t, te - min_t, es - min_e, ee - min_e) for (profiler, ts, te, es, ee) in log_data]
def process_config_dir(config_dir):
"""Process a configuration directory.
Return: [(trial, [(profiler name, [start times], [end times], [start energies], [end energies])])]
Keyword arguments:
config_dir -- the directory for this configuration - contains subdirectories for each trial
"""
return [(trial_dir, process_trial_dir(path.join(config_dir, trial_dir))) for trial_dir in os.listdir(config_dir)]
def process_logs(log_dir):
"""Process log directory.
Return: [(config, [(trial, [(profiler name, [start times], [end times], [start energies], [end energies])])])]
Keyword arguments:
log_dir -- the log directory to process - contains subdirectories for each configuration
"""
return [((config_dir.split('_')[1], process_config_dir(path.join(log_dir, config_dir))))
for config_dir in os.listdir(log_dir)]
def find_best_executions(log_dir):
"""Get the best time, energy, and power from the characterization summaries.
Return: ((config, trial, min_time), (config, trial, min_energy), (config, trial, min_power))
Keyword arguments:
results -- the results from process_logs(...).
"""
DEFAULT = ('', '', 1000000000.0)
min_time = DEFAULT
min_energy = DEFAULT
min_power = DEFAULT
for config_dir in os.listdir(log_dir):
for trial_dir in os.listdir(path.join(log_dir, config_dir)):
with open(path.join(log_dir, config_dir, trial_dir, SUMMARY_OUTPUT), "r") as s:
lines = s.readlines()
time = float(lines[SUMMARY_TIME_IDX].split(':')[1])
energy = int(lines[SUMMARY_ENERGY_IDX].split(':')[1])
power = float(lines[SUMMARY_POWER_IDX].split(':')[1])
if time < min_time[2]:
min_time = (config_dir, trial_dir, time)
if energy < min_energy[2]:
min_energy = (config_dir, trial_dir, energy)
if power < min_power:
min_power = (config_dir, trial_dir, power)
return (min_time, min_energy, min_power)
def main():
"""This script processes the log files from the "characterize.py" script and produces visualizations.
"""
# Default log directory
directory = 'heartbeat_logs'
# Default output directory
output_dir = 'plots'
# Default android
android = False
# Parsing the input of the script
parser = argparse.ArgumentParser(description="Process Heartbeat log files from characterization")
parser.add_argument("-d", "--directory",
default=directory,
help="Heartbeat log directory \"-d heartbeat_logs\"")
parser.add_argument("-o", "--output",
default=output_dir,
help="Specify the log output directory, for example \"-o plots\"")
parser.add_argument("--android",
action="store_true",
dest="android",
default=False,
help="Specify if processing results from Android")
args = parser.parse_args()
if args.directory:
directory = args.directory
if args.output:
output_dir = args.output
if args.android:
android = args.android
if not os.path.exists(directory):
print "Input directory does not exist: " + directory
sys.exit(1)
if os.path.exists(output_dir):
print "Output directory already exists: " + output_dir
sys.exit(1)
res = process_logs(directory)
if not android:
best = find_best_executions(directory)
print 'Best time:', best[0]
print 'Best energy:', best[1]
print 'Best power:', best[2]
os.makedirs(output_dir)
plot_all_raw_totals(res, output_dir)
plot_all_time_series(res, output_dir)
if __name__ == "__main__":
main()
| mpl-2.0 |
apevec/RMS | Utils/SaturationSimulation.py | 2 | 4910 | """ Simulate saturation with a moving Gaussian. """
from __future__ import print_function, division, absolute_import
import numpy as np
import matplotlib.pyplot as plt
import scipy.optimize
# Import Cython functions
import pyximport
pyximport.install(setup_args={'include_dirs':[np.get_include()]})
from Utils.SaturationTools import addGaussian
def simulateSaturation(app_mag, mag_app_saturated_input, photom_offset, bg_val, fps, ang_vel, gauss_sigma, \
steps, saturation_point, show_plot=False):
# Compute the log sum pixel
lsp = app_mag - photom_offset
# Compute the intensity sum from the magnitude
intens_sum = 10**(-lsp/2.5)
# Compute the border as 3 sigma + padding
border = 3*gauss_sigma + 10
# If the intensity sum is larger than the sum of half the windows saturating, scale it up
intens_sum_saturated = 10**(-(mag_app_saturated_input - photom_offset)/2.5)
if intens_sum_saturated > ((border/2.0)**2)*saturation_point:
border = 4*np.sqrt(intens_sum_saturated/saturation_point)
# Limit the border to 50 px
if border > 50:
border = 50
# Estimate the image size
track_length = int(ang_vel/fps + 2*border)
# Init the frame buffer
frame = np.zeros(shape=(track_length, track_length), dtype=np.float64)
# Init evaluation plane
X = np.linspace(0, track_length - 1, track_length)
Y = np.linspace(0, track_length - 1, track_length)
X, Y = np.meshgrid(X, Y)
# Pack X and Y into a single 3-dimensional array
pos = np.empty(X.shape + (2,))
pos[:, :, 0] = X
pos[:, :, 1] = Y
# Compute the Gaussian amplitude
A = intens_sum/(2*np.pi*gauss_sigma**2)
# Normalize the ampllitude to the number of steps
A /= steps
# Move and evaluate the Gaussian at every step
for n in range(steps):
# Compute the location of the Gaussian
x = y = (n/steps)*(ang_vel/fps) + border
frame = addGaussian(frame, x, y, A, gauss_sigma, 3*border)
# Compute the real magnitude
lsp_unsaturated = -2.5*np.log10(np.sum(frame))
mag_app_unsaturated = lsp_unsaturated + photom_offset
#print('Unsaturated magnitude:', mag_app_unsaturated)
# Add the background
frame += bg_val
# Clip the image
frame = np.clip(frame, 0, saturation_point)
# Compute the saturated magnitude
lsp_saturated = -2.5*np.log10(np.sum(frame - bg_val))
mag_app_saturated = lsp_saturated + photom_offset
#print('Modelled saturated magnitude:', mag_app_saturated)
if show_plot:
plt.imshow(frame, cmap='gray', vmin=0, vmax=255)
plt.show()
return mag_app_unsaturated, mag_app_saturated
def findUnsaturatedMagnitude(app_mag, photom_offset, bg_val, fps, ang_vel, gauss_sigma, steps=50, \
saturation_point=255):
def _costFunc(mag_app_unsaturated, params):
mag_app = params[0]
# Compute the unsatured magnitude
_, mag_app_saturated = simulateSaturation(mag_app_unsaturated, *params)
# Compute the residuals
return abs(mag_app - mag_app_saturated)
# Numerically find the position angle
res = scipy.optimize.minimize(_costFunc, [-1], args=([app_mag, photom_offset, bg_val, fps, ang_vel, \
gauss_sigma, steps, saturation_point]), method='Nelder-Mead')
# ## TEST
# simulateSaturation(res.x[0], app_mag, photom_offset, bg_val, fps, ang_vel, \
# gauss_sigma, steps, saturation_point, show_plot=True)
return res.x[0]
if __name__ == "__main__":
photom_offset = 10.7
background_lvl = 60
fps = 25
ang_vel = 250 # px/s
#print(findUnsaturatedMagnitude(-0.5, photom_offset, 50, 25, 100, 1))
#print(simulateSaturation(-10.0, photom_offset, 50, 25, 100, 1, 100, 255))
# Generate the range of apparent (possibly saturated) magnitudes
app_mag_range = np.append(np.linspace(-0.5, 2, 1000), np.linspace(2, 6, 10))
# Generate a range of gaussian stddevs
gauss_stddevs = [1.5, 1.3, 1.15]
for stddev in gauss_stddevs:
unsaturated_mags = []
for app_mag in app_mag_range:
# Compute the unsaturated magnitude
mag_app_unsaturated = findUnsaturatedMagnitude(app_mag, photom_offset, background_lvl, fps, \
ang_vel, stddev)
print(app_mag, mag_app_unsaturated)
unsaturated_mags.append(mag_app_unsaturated)
plt.plot(unsaturated_mags, app_mag_range, label='$\sigma = {:.2f}$'.format(stddev))
plt.plot(app_mag_range, app_mag_range, color='k', linestyle='--', label='No saturation')
plt.gca().invert_yaxis()
plt.gca().invert_xaxis()
plt.axes().set_aspect('equal', 'box')
plt.xlabel('Actual magnitude')
plt.ylabel('Apparent magnitude')
plt.grid()
plt.legend()
plt.tight_layout()
plt.savefig('saturation_sim.png', dpi=300)
plt.show()
| gpl-3.0 |
rs2/pandas | pandas/tests/frame/test_arithmetic.py | 1 | 54436 | from collections import deque
from datetime import datetime
import operator
import re
import numpy as np
import pytest
import pytz
import pandas as pd
from pandas import DataFrame, MultiIndex, Series
import pandas._testing as tm
import pandas.core.common as com
from pandas.core.computation.expressions import _MIN_ELEMENTS, NUMEXPR_INSTALLED
from pandas.tests.frame.common import _check_mixed_float, _check_mixed_int
# -------------------------------------------------------------------
# Comparisons
class TestFrameComparisons:
# Specifically _not_ flex-comparisons
def test_frame_in_list(self):
# GH#12689 this should raise at the DataFrame level, not blocks
df = pd.DataFrame(np.random.randn(6, 4), columns=list("ABCD"))
msg = "The truth value of a DataFrame is ambiguous"
with pytest.raises(ValueError, match=msg):
df in [None]
def test_comparison_invalid(self):
def check(df, df2):
for (x, y) in [(df, df2), (df2, df)]:
# we expect the result to match Series comparisons for
# == and !=, inequalities should raise
result = x == y
expected = pd.DataFrame(
{col: x[col] == y[col] for col in x.columns},
index=x.index,
columns=x.columns,
)
tm.assert_frame_equal(result, expected)
result = x != y
expected = pd.DataFrame(
{col: x[col] != y[col] for col in x.columns},
index=x.index,
columns=x.columns,
)
tm.assert_frame_equal(result, expected)
msgs = [
r"Invalid comparison between dtype=datetime64\[ns\] and ndarray",
"invalid type promotion",
]
msg = "|".join(msgs)
with pytest.raises(TypeError, match=msg):
x >= y
with pytest.raises(TypeError, match=msg):
x > y
with pytest.raises(TypeError, match=msg):
x < y
with pytest.raises(TypeError, match=msg):
x <= y
# GH4968
# invalid date/int comparisons
df = pd.DataFrame(np.random.randint(10, size=(10, 1)), columns=["a"])
df["dates"] = pd.date_range("20010101", periods=len(df))
df2 = df.copy()
df2["dates"] = df["a"]
check(df, df2)
df = pd.DataFrame(np.random.randint(10, size=(10, 2)), columns=["a", "b"])
df2 = pd.DataFrame(
{
"a": pd.date_range("20010101", periods=len(df)),
"b": pd.date_range("20100101", periods=len(df)),
}
)
check(df, df2)
def test_timestamp_compare(self):
# make sure we can compare Timestamps on the right AND left hand side
# GH#4982
df = pd.DataFrame(
{
"dates1": pd.date_range("20010101", periods=10),
"dates2": pd.date_range("20010102", periods=10),
"intcol": np.random.randint(1000000000, size=10),
"floatcol": np.random.randn(10),
"stringcol": list(tm.rands(10)),
}
)
df.loc[np.random.rand(len(df)) > 0.5, "dates2"] = pd.NaT
ops = {"gt": "lt", "lt": "gt", "ge": "le", "le": "ge", "eq": "eq", "ne": "ne"}
for left, right in ops.items():
left_f = getattr(operator, left)
right_f = getattr(operator, right)
# no nats
if left in ["eq", "ne"]:
expected = left_f(df, pd.Timestamp("20010109"))
result = right_f(pd.Timestamp("20010109"), df)
tm.assert_frame_equal(result, expected)
else:
msg = (
"'(<|>)=?' not supported between "
"instances of 'numpy.ndarray' and 'Timestamp'"
)
with pytest.raises(TypeError, match=msg):
left_f(df, pd.Timestamp("20010109"))
with pytest.raises(TypeError, match=msg):
right_f(pd.Timestamp("20010109"), df)
# nats
expected = left_f(df, pd.Timestamp("nat"))
result = right_f(pd.Timestamp("nat"), df)
tm.assert_frame_equal(result, expected)
def test_mixed_comparison(self):
# GH#13128, GH#22163 != datetime64 vs non-dt64 should be False,
# not raise TypeError
# (this appears to be fixed before GH#22163, not sure when)
df = pd.DataFrame([["1989-08-01", 1], ["1989-08-01", 2]])
other = pd.DataFrame([["a", "b"], ["c", "d"]])
result = df == other
assert not result.any().any()
result = df != other
assert result.all().all()
def test_df_boolean_comparison_error(self):
# GH#4576, GH#22880
# comparing DataFrame against list/tuple with len(obj) matching
# len(df.columns) is supported as of GH#22800
df = pd.DataFrame(np.arange(6).reshape((3, 2)))
expected = pd.DataFrame([[False, False], [True, False], [False, False]])
result = df == (2, 2)
tm.assert_frame_equal(result, expected)
result = df == [2, 2]
tm.assert_frame_equal(result, expected)
def test_df_float_none_comparison(self):
df = pd.DataFrame(
np.random.randn(8, 3), index=range(8), columns=["A", "B", "C"]
)
result = df.__eq__(None)
assert not result.any().any()
def test_df_string_comparison(self):
df = pd.DataFrame([{"a": 1, "b": "foo"}, {"a": 2, "b": "bar"}])
mask_a = df.a > 1
tm.assert_frame_equal(df[mask_a], df.loc[1:1, :])
tm.assert_frame_equal(df[-mask_a], df.loc[0:0, :])
mask_b = df.b == "foo"
tm.assert_frame_equal(df[mask_b], df.loc[0:0, :])
tm.assert_frame_equal(df[-mask_b], df.loc[1:1, :])
class TestFrameFlexComparisons:
# TODO: test_bool_flex_frame needs a better name
def test_bool_flex_frame(self):
data = np.random.randn(5, 3)
other_data = np.random.randn(5, 3)
df = pd.DataFrame(data)
other = pd.DataFrame(other_data)
ndim_5 = np.ones(df.shape + (1, 3))
# Unaligned
def _check_unaligned_frame(meth, op, df, other):
part_o = other.loc[3:, 1:].copy()
rs = meth(part_o)
xp = op(df, part_o.reindex(index=df.index, columns=df.columns))
tm.assert_frame_equal(rs, xp)
# DataFrame
assert df.eq(df).values.all()
assert not df.ne(df).values.any()
for op in ["eq", "ne", "gt", "lt", "ge", "le"]:
f = getattr(df, op)
o = getattr(operator, op)
# No NAs
tm.assert_frame_equal(f(other), o(df, other))
_check_unaligned_frame(f, o, df, other)
# ndarray
tm.assert_frame_equal(f(other.values), o(df, other.values))
# scalar
tm.assert_frame_equal(f(0), o(df, 0))
# NAs
msg = "Unable to coerce to Series/DataFrame"
tm.assert_frame_equal(f(np.nan), o(df, np.nan))
with pytest.raises(ValueError, match=msg):
f(ndim_5)
# Series
def _test_seq(df, idx_ser, col_ser):
idx_eq = df.eq(idx_ser, axis=0)
col_eq = df.eq(col_ser)
idx_ne = df.ne(idx_ser, axis=0)
col_ne = df.ne(col_ser)
tm.assert_frame_equal(col_eq, df == pd.Series(col_ser))
tm.assert_frame_equal(col_eq, -col_ne)
tm.assert_frame_equal(idx_eq, -idx_ne)
tm.assert_frame_equal(idx_eq, df.T.eq(idx_ser).T)
tm.assert_frame_equal(col_eq, df.eq(list(col_ser)))
tm.assert_frame_equal(idx_eq, df.eq(pd.Series(idx_ser), axis=0))
tm.assert_frame_equal(idx_eq, df.eq(list(idx_ser), axis=0))
idx_gt = df.gt(idx_ser, axis=0)
col_gt = df.gt(col_ser)
idx_le = df.le(idx_ser, axis=0)
col_le = df.le(col_ser)
tm.assert_frame_equal(col_gt, df > pd.Series(col_ser))
tm.assert_frame_equal(col_gt, -col_le)
tm.assert_frame_equal(idx_gt, -idx_le)
tm.assert_frame_equal(idx_gt, df.T.gt(idx_ser).T)
idx_ge = df.ge(idx_ser, axis=0)
col_ge = df.ge(col_ser)
idx_lt = df.lt(idx_ser, axis=0)
col_lt = df.lt(col_ser)
tm.assert_frame_equal(col_ge, df >= pd.Series(col_ser))
tm.assert_frame_equal(col_ge, -col_lt)
tm.assert_frame_equal(idx_ge, -idx_lt)
tm.assert_frame_equal(idx_ge, df.T.ge(idx_ser).T)
idx_ser = pd.Series(np.random.randn(5))
col_ser = pd.Series(np.random.randn(3))
_test_seq(df, idx_ser, col_ser)
# list/tuple
_test_seq(df, idx_ser.values, col_ser.values)
# NA
df.loc[0, 0] = np.nan
rs = df.eq(df)
assert not rs.loc[0, 0]
rs = df.ne(df)
assert rs.loc[0, 0]
rs = df.gt(df)
assert not rs.loc[0, 0]
rs = df.lt(df)
assert not rs.loc[0, 0]
rs = df.ge(df)
assert not rs.loc[0, 0]
rs = df.le(df)
assert not rs.loc[0, 0]
def test_bool_flex_frame_complex_dtype(self):
# complex
arr = np.array([np.nan, 1, 6, np.nan])
arr2 = np.array([2j, np.nan, 7, None])
df = pd.DataFrame({"a": arr})
df2 = pd.DataFrame({"a": arr2})
msg = "|".join(
[
"'>' not supported between instances of '.*' and 'complex'",
r"unorderable types: .*complex\(\)", # PY35
]
)
with pytest.raises(TypeError, match=msg):
# inequalities are not well-defined for complex numbers
df.gt(df2)
with pytest.raises(TypeError, match=msg):
# regression test that we get the same behavior for Series
df["a"].gt(df2["a"])
with pytest.raises(TypeError, match=msg):
# Check that we match numpy behavior here
df.values > df2.values
rs = df.ne(df2)
assert rs.values.all()
arr3 = np.array([2j, np.nan, None])
df3 = pd.DataFrame({"a": arr3})
with pytest.raises(TypeError, match=msg):
# inequalities are not well-defined for complex numbers
df3.gt(2j)
with pytest.raises(TypeError, match=msg):
# regression test that we get the same behavior for Series
df3["a"].gt(2j)
with pytest.raises(TypeError, match=msg):
# Check that we match numpy behavior here
df3.values > 2j
def test_bool_flex_frame_object_dtype(self):
# corner, dtype=object
df1 = pd.DataFrame({"col": ["foo", np.nan, "bar"]})
df2 = pd.DataFrame({"col": ["foo", datetime.now(), "bar"]})
result = df1.ne(df2)
exp = pd.DataFrame({"col": [False, True, False]})
tm.assert_frame_equal(result, exp)
def test_flex_comparison_nat(self):
# GH 15697, GH 22163 df.eq(pd.NaT) should behave like df == pd.NaT,
# and _definitely_ not be NaN
df = pd.DataFrame([pd.NaT])
result = df == pd.NaT
# result.iloc[0, 0] is a np.bool_ object
assert result.iloc[0, 0].item() is False
result = df.eq(pd.NaT)
assert result.iloc[0, 0].item() is False
result = df != pd.NaT
assert result.iloc[0, 0].item() is True
result = df.ne(pd.NaT)
assert result.iloc[0, 0].item() is True
@pytest.mark.parametrize("opname", ["eq", "ne", "gt", "lt", "ge", "le"])
def test_df_flex_cmp_constant_return_types(self, opname):
# GH 15077, non-empty DataFrame
df = pd.DataFrame({"x": [1, 2, 3], "y": [1.0, 2.0, 3.0]})
const = 2
result = getattr(df, opname)(const).dtypes.value_counts()
tm.assert_series_equal(result, pd.Series([2], index=[np.dtype(bool)]))
@pytest.mark.parametrize("opname", ["eq", "ne", "gt", "lt", "ge", "le"])
def test_df_flex_cmp_constant_return_types_empty(self, opname):
# GH 15077 empty DataFrame
df = pd.DataFrame({"x": [1, 2, 3], "y": [1.0, 2.0, 3.0]})
const = 2
empty = df.iloc[:0]
result = getattr(empty, opname)(const).dtypes.value_counts()
tm.assert_series_equal(result, pd.Series([2], index=[np.dtype(bool)]))
def test_df_flex_cmp_ea_dtype_with_ndarray_series(self):
ii = pd.IntervalIndex.from_breaks([1, 2, 3])
df = pd.DataFrame({"A": ii, "B": ii})
ser = pd.Series([0, 0])
res = df.eq(ser, axis=0)
expected = pd.DataFrame({"A": [False, False], "B": [False, False]})
tm.assert_frame_equal(res, expected)
ser2 = pd.Series([1, 2], index=["A", "B"])
res2 = df.eq(ser2, axis=1)
tm.assert_frame_equal(res2, expected)
# -------------------------------------------------------------------
# Arithmetic
class TestFrameFlexArithmetic:
def test_floordiv_axis0(self):
# make sure we df.floordiv(ser, axis=0) matches column-wise result
arr = np.arange(3)
ser = pd.Series(arr)
df = pd.DataFrame({"A": ser, "B": ser})
result = df.floordiv(ser, axis=0)
expected = pd.DataFrame({col: df[col] // ser for col in df.columns})
tm.assert_frame_equal(result, expected)
result2 = df.floordiv(ser.values, axis=0)
tm.assert_frame_equal(result2, expected)
@pytest.mark.skipif(not NUMEXPR_INSTALLED, reason="numexpr not installed")
@pytest.mark.parametrize("opname", ["floordiv", "pow"])
def test_floordiv_axis0_numexpr_path(self, opname):
# case that goes through numexpr and has to fall back to masked_arith_op
op = getattr(operator, opname)
arr = np.arange(_MIN_ELEMENTS + 100).reshape(_MIN_ELEMENTS // 100 + 1, -1) * 100
df = pd.DataFrame(arr)
df["C"] = 1.0
ser = df[0]
result = getattr(df, opname)(ser, axis=0)
expected = pd.DataFrame({col: op(df[col], ser) for col in df.columns})
tm.assert_frame_equal(result, expected)
result2 = getattr(df, opname)(ser.values, axis=0)
tm.assert_frame_equal(result2, expected)
def test_df_add_td64_columnwise(self):
# GH 22534 Check that column-wise addition broadcasts correctly
dti = pd.date_range("2016-01-01", periods=10)
tdi = pd.timedelta_range("1", periods=10)
tser = pd.Series(tdi)
df = pd.DataFrame({0: dti, 1: tdi})
result = df.add(tser, axis=0)
expected = pd.DataFrame({0: dti + tdi, 1: tdi + tdi})
tm.assert_frame_equal(result, expected)
def test_df_add_flex_filled_mixed_dtypes(self):
# GH 19611
dti = pd.date_range("2016-01-01", periods=3)
ser = pd.Series(["1 Day", "NaT", "2 Days"], dtype="timedelta64[ns]")
df = pd.DataFrame({"A": dti, "B": ser})
other = pd.DataFrame({"A": ser, "B": ser})
fill = pd.Timedelta(days=1).to_timedelta64()
result = df.add(other, fill_value=fill)
expected = pd.DataFrame(
{
"A": pd.Series(
["2016-01-02", "2016-01-03", "2016-01-05"], dtype="datetime64[ns]"
),
"B": ser * 2,
}
)
tm.assert_frame_equal(result, expected)
def test_arith_flex_frame(
self, all_arithmetic_operators, float_frame, mixed_float_frame
):
# one instance of parametrized fixture
op = all_arithmetic_operators
def f(x, y):
# r-versions not in operator-stdlib; get op without "r" and invert
if op.startswith("__r"):
return getattr(operator, op.replace("__r", "__"))(y, x)
return getattr(operator, op)(x, y)
result = getattr(float_frame, op)(2 * float_frame)
expected = f(float_frame, 2 * float_frame)
tm.assert_frame_equal(result, expected)
# vs mix float
result = getattr(mixed_float_frame, op)(2 * mixed_float_frame)
expected = f(mixed_float_frame, 2 * mixed_float_frame)
tm.assert_frame_equal(result, expected)
_check_mixed_float(result, dtype=dict(C=None))
@pytest.mark.parametrize("op", ["__add__", "__sub__", "__mul__"])
def test_arith_flex_frame_mixed(
self, op, int_frame, mixed_int_frame, mixed_float_frame
):
f = getattr(operator, op)
# vs mix int
result = getattr(mixed_int_frame, op)(2 + mixed_int_frame)
expected = f(mixed_int_frame, 2 + mixed_int_frame)
# no overflow in the uint
dtype = None
if op in ["__sub__"]:
dtype = dict(B="uint64", C=None)
elif op in ["__add__", "__mul__"]:
dtype = dict(C=None)
tm.assert_frame_equal(result, expected)
_check_mixed_int(result, dtype=dtype)
# vs mix float
result = getattr(mixed_float_frame, op)(2 * mixed_float_frame)
expected = f(mixed_float_frame, 2 * mixed_float_frame)
tm.assert_frame_equal(result, expected)
_check_mixed_float(result, dtype=dict(C=None))
# vs plain int
result = getattr(int_frame, op)(2 * int_frame)
expected = f(int_frame, 2 * int_frame)
tm.assert_frame_equal(result, expected)
def test_arith_flex_frame_raise(self, all_arithmetic_operators, float_frame):
# one instance of parametrized fixture
op = all_arithmetic_operators
# Check that arrays with dim >= 3 raise
for dim in range(3, 6):
arr = np.ones((1,) * dim)
msg = "Unable to coerce to Series/DataFrame"
with pytest.raises(ValueError, match=msg):
getattr(float_frame, op)(arr)
def test_arith_flex_frame_corner(self, float_frame):
const_add = float_frame.add(1)
tm.assert_frame_equal(const_add, float_frame + 1)
# corner cases
result = float_frame.add(float_frame[:0])
tm.assert_frame_equal(result, float_frame * np.nan)
result = float_frame[:0].add(float_frame)
tm.assert_frame_equal(result, float_frame * np.nan)
with pytest.raises(NotImplementedError, match="fill_value"):
float_frame.add(float_frame.iloc[0], fill_value=3)
with pytest.raises(NotImplementedError, match="fill_value"):
float_frame.add(float_frame.iloc[0], axis="index", fill_value=3)
def test_arith_flex_series(self, simple_frame):
df = simple_frame
row = df.xs("a")
col = df["two"]
# after arithmetic refactor, add truediv here
ops = ["add", "sub", "mul", "mod"]
for op in ops:
f = getattr(df, op)
op = getattr(operator, op)
tm.assert_frame_equal(f(row), op(df, row))
tm.assert_frame_equal(f(col, axis=0), op(df.T, col).T)
# special case for some reason
tm.assert_frame_equal(df.add(row, axis=None), df + row)
# cases which will be refactored after big arithmetic refactor
tm.assert_frame_equal(df.div(row), df / row)
tm.assert_frame_equal(df.div(col, axis=0), (df.T / col).T)
# broadcasting issue in GH 7325
df = pd.DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype="int64")
expected = pd.DataFrame([[np.nan, np.inf], [1.0, 1.5], [1.0, 1.25]])
result = df.div(df[0], axis="index")
tm.assert_frame_equal(result, expected)
df = pd.DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype="float64")
expected = pd.DataFrame([[np.nan, np.inf], [1.0, 1.5], [1.0, 1.25]])
result = df.div(df[0], axis="index")
tm.assert_frame_equal(result, expected)
def test_arith_flex_zero_len_raises(self):
# GH 19522 passing fill_value to frame flex arith methods should
# raise even in the zero-length special cases
ser_len0 = pd.Series([], dtype=object)
df_len0 = pd.DataFrame(columns=["A", "B"])
df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
with pytest.raises(NotImplementedError, match="fill_value"):
df.add(ser_len0, fill_value="E")
with pytest.raises(NotImplementedError, match="fill_value"):
df_len0.sub(df["A"], axis=None, fill_value=3)
def test_flex_add_scalar_fill_value(self):
# GH#12723
dat = np.array([0, 1, np.nan, 3, 4, 5], dtype="float")
df = pd.DataFrame({"foo": dat}, index=range(6))
exp = df.fillna(0).add(2)
res = df.add(2, fill_value=0)
tm.assert_frame_equal(res, exp)
class TestFrameArithmetic:
def test_td64_op_nat_casting(self):
# Make sure we don't accidentally treat timedelta64(NaT) as datetime64
# when calling dispatch_to_series in DataFrame arithmetic
ser = pd.Series(["NaT", "NaT"], dtype="timedelta64[ns]")
df = pd.DataFrame([[1, 2], [3, 4]])
result = df * ser
expected = pd.DataFrame({0: ser, 1: ser})
tm.assert_frame_equal(result, expected)
def test_df_add_2d_array_rowlike_broadcasts(self):
# GH#23000
arr = np.arange(6).reshape(3, 2)
df = pd.DataFrame(arr, columns=[True, False], index=["A", "B", "C"])
rowlike = arr[[1], :] # shape --> (1, ncols)
assert rowlike.shape == (1, df.shape[1])
expected = pd.DataFrame(
[[2, 4], [4, 6], [6, 8]],
columns=df.columns,
index=df.index,
# specify dtype explicitly to avoid failing
# on 32bit builds
dtype=arr.dtype,
)
result = df + rowlike
tm.assert_frame_equal(result, expected)
result = rowlike + df
tm.assert_frame_equal(result, expected)
def test_df_add_2d_array_collike_broadcasts(self):
# GH#23000
arr = np.arange(6).reshape(3, 2)
df = pd.DataFrame(arr, columns=[True, False], index=["A", "B", "C"])
collike = arr[:, [1]] # shape --> (nrows, 1)
assert collike.shape == (df.shape[0], 1)
expected = pd.DataFrame(
[[1, 2], [5, 6], [9, 10]],
columns=df.columns,
index=df.index,
# specify dtype explicitly to avoid failing
# on 32bit builds
dtype=arr.dtype,
)
result = df + collike
tm.assert_frame_equal(result, expected)
result = collike + df
tm.assert_frame_equal(result, expected)
def test_df_arith_2d_array_rowlike_broadcasts(self, all_arithmetic_operators):
# GH#23000
opname = all_arithmetic_operators
arr = np.arange(6).reshape(3, 2)
df = pd.DataFrame(arr, columns=[True, False], index=["A", "B", "C"])
rowlike = arr[[1], :] # shape --> (1, ncols)
assert rowlike.shape == (1, df.shape[1])
exvals = [
getattr(df.loc["A"], opname)(rowlike.squeeze()),
getattr(df.loc["B"], opname)(rowlike.squeeze()),
getattr(df.loc["C"], opname)(rowlike.squeeze()),
]
expected = pd.DataFrame(exvals, columns=df.columns, index=df.index)
result = getattr(df, opname)(rowlike)
tm.assert_frame_equal(result, expected)
def test_df_arith_2d_array_collike_broadcasts(self, all_arithmetic_operators):
# GH#23000
opname = all_arithmetic_operators
arr = np.arange(6).reshape(3, 2)
df = pd.DataFrame(arr, columns=[True, False], index=["A", "B", "C"])
collike = arr[:, [1]] # shape --> (nrows, 1)
assert collike.shape == (df.shape[0], 1)
exvals = {
True: getattr(df[True], opname)(collike.squeeze()),
False: getattr(df[False], opname)(collike.squeeze()),
}
dtype = None
if opname in ["__rmod__", "__rfloordiv__"]:
# Series ops may return mixed int/float dtypes in cases where
# DataFrame op will return all-float. So we upcast `expected`
dtype = np.common_type(*[x.values for x in exvals.values()])
expected = pd.DataFrame(exvals, columns=df.columns, index=df.index, dtype=dtype)
result = getattr(df, opname)(collike)
tm.assert_frame_equal(result, expected)
def test_df_bool_mul_int(self):
# GH 22047, GH 22163 multiplication by 1 should result in int dtype,
# not object dtype
df = pd.DataFrame([[False, True], [False, False]])
result = df * 1
# On appveyor this comes back as np.int32 instead of np.int64,
# so we check dtype.kind instead of just dtype
kinds = result.dtypes.apply(lambda x: x.kind)
assert (kinds == "i").all()
result = 1 * df
kinds = result.dtypes.apply(lambda x: x.kind)
assert (kinds == "i").all()
def test_arith_mixed(self):
left = pd.DataFrame({"A": ["a", "b", "c"], "B": [1, 2, 3]})
result = left + left
expected = pd.DataFrame({"A": ["aa", "bb", "cc"], "B": [2, 4, 6]})
tm.assert_frame_equal(result, expected)
def test_arith_getitem_commute(self):
df = pd.DataFrame({"A": [1.1, 3.3], "B": [2.5, -3.9]})
def _test_op(df, op):
result = op(df, 1)
if not df.columns.is_unique:
raise ValueError("Only unique columns supported by this test")
for col in result.columns:
tm.assert_series_equal(result[col], op(df[col], 1))
_test_op(df, operator.add)
_test_op(df, operator.sub)
_test_op(df, operator.mul)
_test_op(df, operator.truediv)
_test_op(df, operator.floordiv)
_test_op(df, operator.pow)
_test_op(df, lambda x, y: y + x)
_test_op(df, lambda x, y: y - x)
_test_op(df, lambda x, y: y * x)
_test_op(df, lambda x, y: y / x)
_test_op(df, lambda x, y: y ** x)
_test_op(df, lambda x, y: x + y)
_test_op(df, lambda x, y: x - y)
_test_op(df, lambda x, y: x * y)
_test_op(df, lambda x, y: x / y)
_test_op(df, lambda x, y: x ** y)
@pytest.mark.parametrize(
"values", [[1, 2], (1, 2), np.array([1, 2]), range(1, 3), deque([1, 2])]
)
def test_arith_alignment_non_pandas_object(self, values):
# GH#17901
df = pd.DataFrame({"A": [1, 1], "B": [1, 1]})
expected = pd.DataFrame({"A": [2, 2], "B": [3, 3]})
result = df + values
tm.assert_frame_equal(result, expected)
def test_arith_non_pandas_object(self):
df = pd.DataFrame(
np.arange(1, 10, dtype="f8").reshape(3, 3),
columns=["one", "two", "three"],
index=["a", "b", "c"],
)
val1 = df.xs("a").values
added = pd.DataFrame(df.values + val1, index=df.index, columns=df.columns)
tm.assert_frame_equal(df + val1, added)
added = pd.DataFrame((df.values.T + val1).T, index=df.index, columns=df.columns)
tm.assert_frame_equal(df.add(val1, axis=0), added)
val2 = list(df["two"])
added = pd.DataFrame(df.values + val2, index=df.index, columns=df.columns)
tm.assert_frame_equal(df + val2, added)
added = pd.DataFrame((df.values.T + val2).T, index=df.index, columns=df.columns)
tm.assert_frame_equal(df.add(val2, axis="index"), added)
val3 = np.random.rand(*df.shape)
added = pd.DataFrame(df.values + val3, index=df.index, columns=df.columns)
tm.assert_frame_equal(df.add(val3), added)
def test_operations_with_interval_categories_index(self, all_arithmetic_operators):
# GH#27415
op = all_arithmetic_operators
ind = pd.CategoricalIndex(pd.interval_range(start=0.0, end=2.0))
data = [1, 2]
df = pd.DataFrame([data], columns=ind)
num = 10
result = getattr(df, op)(num)
expected = pd.DataFrame([[getattr(n, op)(num) for n in data]], columns=ind)
tm.assert_frame_equal(result, expected)
def test_frame_with_frame_reindex(self):
# GH#31623
df = pd.DataFrame(
{
"foo": [pd.Timestamp("2019"), pd.Timestamp("2020")],
"bar": [pd.Timestamp("2018"), pd.Timestamp("2021")],
},
columns=["foo", "bar"],
)
df2 = df[["foo"]]
result = df - df2
expected = pd.DataFrame(
{"foo": [pd.Timedelta(0), pd.Timedelta(0)], "bar": [np.nan, np.nan]},
columns=["bar", "foo"],
)
tm.assert_frame_equal(result, expected)
def test_frame_with_zero_len_series_corner_cases():
# GH#28600
# easy all-float case
df = pd.DataFrame(np.random.randn(6).reshape(3, 2), columns=["A", "B"])
ser = pd.Series(dtype=np.float64)
result = df + ser
expected = pd.DataFrame(df.values * np.nan, columns=df.columns)
tm.assert_frame_equal(result, expected)
result = df == ser
expected = pd.DataFrame(False, index=df.index, columns=df.columns)
tm.assert_frame_equal(result, expected)
# non-float case should not raise on comparison
df2 = pd.DataFrame(df.values.view("M8[ns]"), columns=df.columns)
result = df2 == ser
expected = pd.DataFrame(False, index=df.index, columns=df.columns)
tm.assert_frame_equal(result, expected)
def test_zero_len_frame_with_series_corner_cases():
# GH#28600
df = pd.DataFrame(columns=["A", "B"], dtype=np.float64)
ser = pd.Series([1, 2], index=["A", "B"])
result = df + ser
expected = df
tm.assert_frame_equal(result, expected)
def test_frame_single_columns_object_sum_axis_1():
# GH 13758
data = {
"One": pd.Series(["A", 1.2, np.nan]),
}
df = pd.DataFrame(data)
result = df.sum(axis=1)
expected = pd.Series(["A", 1.2, 0])
tm.assert_series_equal(result, expected)
# -------------------------------------------------------------------
# Unsorted
# These arithmetic tests were previously in other files, eventually
# should be parametrized and put into tests.arithmetic
class TestFrameArithmeticUnsorted:
def test_frame_add_tz_mismatch_converts_to_utc(self):
rng = pd.date_range("1/1/2011", periods=10, freq="H", tz="US/Eastern")
df = pd.DataFrame(np.random.randn(len(rng)), index=rng, columns=["a"])
df_moscow = df.tz_convert("Europe/Moscow")
result = df + df_moscow
assert result.index.tz is pytz.utc
result = df_moscow + df
assert result.index.tz is pytz.utc
def test_align_frame(self):
rng = pd.period_range("1/1/2000", "1/1/2010", freq="A")
ts = pd.DataFrame(np.random.randn(len(rng), 3), index=rng)
result = ts + ts[::2]
expected = ts + ts
expected.values[1::2] = np.nan
tm.assert_frame_equal(result, expected)
half = ts[::2]
result = ts + half.take(np.random.permutation(len(half)))
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize(
"op", [operator.add, operator.sub, operator.mul, operator.truediv]
)
def test_operators_none_as_na(self, op):
df = DataFrame(
{"col1": [2, 5.0, 123, None], "col2": [1, 2, 3, 4]}, dtype=object
)
# since filling converts dtypes from object, changed expected to be
# object
filled = df.fillna(np.nan)
result = op(df, 3)
expected = op(filled, 3).astype(object)
expected[com.isna(expected)] = None
tm.assert_frame_equal(result, expected)
result = op(df, df)
expected = op(filled, filled).astype(object)
expected[com.isna(expected)] = None
tm.assert_frame_equal(result, expected)
result = op(df, df.fillna(7))
tm.assert_frame_equal(result, expected)
result = op(df.fillna(7), df)
tm.assert_frame_equal(result, expected, check_dtype=False)
@pytest.mark.parametrize("op,res", [("__eq__", False), ("__ne__", True)])
# TODO: not sure what's correct here.
@pytest.mark.filterwarnings("ignore:elementwise:FutureWarning")
def test_logical_typeerror_with_non_valid(self, op, res, float_frame):
# we are comparing floats vs a string
result = getattr(float_frame, op)("foo")
assert bool(result.all().all()) is res
def test_binary_ops_align(self):
# test aligning binary ops
# GH 6681
index = MultiIndex.from_product(
[list("abc"), ["one", "two", "three"], [1, 2, 3]],
names=["first", "second", "third"],
)
df = DataFrame(
np.arange(27 * 3).reshape(27, 3),
index=index,
columns=["value1", "value2", "value3"],
).sort_index()
idx = pd.IndexSlice
for op in ["add", "sub", "mul", "div", "truediv"]:
opa = getattr(operator, op, None)
if opa is None:
continue
x = Series([1.0, 10.0, 100.0], [1, 2, 3])
result = getattr(df, op)(x, level="third", axis=0)
expected = pd.concat(
[opa(df.loc[idx[:, :, i], :], v) for i, v in x.items()]
).sort_index()
tm.assert_frame_equal(result, expected)
x = Series([1.0, 10.0], ["two", "three"])
result = getattr(df, op)(x, level="second", axis=0)
expected = (
pd.concat([opa(df.loc[idx[:, i], :], v) for i, v in x.items()])
.reindex_like(df)
.sort_index()
)
tm.assert_frame_equal(result, expected)
# GH9463 (alignment level of dataframe with series)
midx = MultiIndex.from_product([["A", "B"], ["a", "b"]])
df = DataFrame(np.ones((2, 4), dtype="int64"), columns=midx)
s = pd.Series({"a": 1, "b": 2})
df2 = df.copy()
df2.columns.names = ["lvl0", "lvl1"]
s2 = s.copy()
s2.index.name = "lvl1"
# different cases of integer/string level names:
res1 = df.mul(s, axis=1, level=1)
res2 = df.mul(s2, axis=1, level=1)
res3 = df2.mul(s, axis=1, level=1)
res4 = df2.mul(s2, axis=1, level=1)
res5 = df2.mul(s, axis=1, level="lvl1")
res6 = df2.mul(s2, axis=1, level="lvl1")
exp = DataFrame(
np.array([[1, 2, 1, 2], [1, 2, 1, 2]], dtype="int64"), columns=midx
)
for res in [res1, res2]:
tm.assert_frame_equal(res, exp)
exp.columns.names = ["lvl0", "lvl1"]
for res in [res3, res4, res5, res6]:
tm.assert_frame_equal(res, exp)
def test_add_with_dti_mismatched_tzs(self):
base = pd.DatetimeIndex(["2011-01-01", "2011-01-02", "2011-01-03"], tz="UTC")
idx1 = base.tz_convert("Asia/Tokyo")[:2]
idx2 = base.tz_convert("US/Eastern")[1:]
df1 = DataFrame({"A": [1, 2]}, index=idx1)
df2 = DataFrame({"A": [1, 1]}, index=idx2)
exp = DataFrame({"A": [np.nan, 3, np.nan]}, index=base)
tm.assert_frame_equal(df1 + df2, exp)
def test_combineFrame(self, float_frame, mixed_float_frame, mixed_int_frame):
frame_copy = float_frame.reindex(float_frame.index[::2])
del frame_copy["D"]
frame_copy["C"][:5] = np.nan
added = float_frame + frame_copy
indexer = added["A"].dropna().index
exp = (float_frame["A"] * 2).copy()
tm.assert_series_equal(added["A"].dropna(), exp.loc[indexer])
exp.loc[~exp.index.isin(indexer)] = np.nan
tm.assert_series_equal(added["A"], exp.loc[added["A"].index])
assert np.isnan(added["C"].reindex(frame_copy.index)[:5]).all()
# assert(False)
assert np.isnan(added["D"]).all()
self_added = float_frame + float_frame
tm.assert_index_equal(self_added.index, float_frame.index)
added_rev = frame_copy + float_frame
assert np.isnan(added["D"]).all()
assert np.isnan(added_rev["D"]).all()
# corner cases
# empty
plus_empty = float_frame + DataFrame()
assert np.isnan(plus_empty.values).all()
empty_plus = DataFrame() + float_frame
assert np.isnan(empty_plus.values).all()
empty_empty = DataFrame() + DataFrame()
assert empty_empty.empty
# out of order
reverse = float_frame.reindex(columns=float_frame.columns[::-1])
tm.assert_frame_equal(reverse + float_frame, float_frame * 2)
# mix vs float64, upcast
added = float_frame + mixed_float_frame
_check_mixed_float(added, dtype="float64")
added = mixed_float_frame + float_frame
_check_mixed_float(added, dtype="float64")
# mix vs mix
added = mixed_float_frame + mixed_float_frame
_check_mixed_float(added, dtype=dict(C=None))
# with int
added = float_frame + mixed_int_frame
_check_mixed_float(added, dtype="float64")
def test_combine_series(
self, float_frame, mixed_float_frame, mixed_int_frame, datetime_frame
):
# Series
series = float_frame.xs(float_frame.index[0])
added = float_frame + series
for key, s in added.items():
tm.assert_series_equal(s, float_frame[key] + series[key])
larger_series = series.to_dict()
larger_series["E"] = 1
larger_series = Series(larger_series)
larger_added = float_frame + larger_series
for key, s in float_frame.items():
tm.assert_series_equal(larger_added[key], s + series[key])
assert "E" in larger_added
assert np.isnan(larger_added["E"]).all()
# no upcast needed
added = mixed_float_frame + series
assert np.all(added.dtypes == series.dtype)
# vs mix (upcast) as needed
added = mixed_float_frame + series.astype("float32")
_check_mixed_float(added, dtype=dict(C=None))
added = mixed_float_frame + series.astype("float16")
_check_mixed_float(added, dtype=dict(C=None))
# FIXME: don't leave commented-out
# these raise with numexpr.....as we are adding an int64 to an
# uint64....weird vs int
# added = mixed_int_frame + (100*series).astype('int64')
# _check_mixed_int(added, dtype = dict(A = 'int64', B = 'float64', C =
# 'int64', D = 'int64'))
# added = mixed_int_frame + (100*series).astype('int32')
# _check_mixed_int(added, dtype = dict(A = 'int32', B = 'float64', C =
# 'int32', D = 'int64'))
# TimeSeries
ts = datetime_frame["A"]
# 10890
# we no longer allow auto timeseries broadcasting
# and require explicit broadcasting
added = datetime_frame.add(ts, axis="index")
for key, col in datetime_frame.items():
result = col + ts
tm.assert_series_equal(added[key], result, check_names=False)
assert added[key].name == key
if col.name == ts.name:
assert result.name == "A"
else:
assert result.name is None
smaller_frame = datetime_frame[:-5]
smaller_added = smaller_frame.add(ts, axis="index")
tm.assert_index_equal(smaller_added.index, datetime_frame.index)
smaller_ts = ts[:-5]
smaller_added2 = datetime_frame.add(smaller_ts, axis="index")
tm.assert_frame_equal(smaller_added, smaller_added2)
# length 0, result is all-nan
result = datetime_frame.add(ts[:0], axis="index")
expected = DataFrame(
np.nan, index=datetime_frame.index, columns=datetime_frame.columns
)
tm.assert_frame_equal(result, expected)
# Frame is all-nan
result = datetime_frame[:0].add(ts, axis="index")
expected = DataFrame(
np.nan, index=datetime_frame.index, columns=datetime_frame.columns
)
tm.assert_frame_equal(result, expected)
# empty but with non-empty index
frame = datetime_frame[:1].reindex(columns=[])
result = frame.mul(ts, axis="index")
assert len(result) == len(ts)
def test_combineFunc(self, float_frame, mixed_float_frame):
result = float_frame * 2
tm.assert_numpy_array_equal(result.values, float_frame.values * 2)
# vs mix
result = mixed_float_frame * 2
for c, s in result.items():
tm.assert_numpy_array_equal(s.values, mixed_float_frame[c].values * 2)
_check_mixed_float(result, dtype=dict(C=None))
result = DataFrame() * 2
assert result.index.equals(DataFrame().index)
assert len(result.columns) == 0
def test_comparisons(self, simple_frame, float_frame):
df1 = tm.makeTimeDataFrame()
df2 = tm.makeTimeDataFrame()
row = simple_frame.xs("a")
ndim_5 = np.ones(df1.shape + (1, 1, 1))
def test_comp(func):
result = func(df1, df2)
tm.assert_numpy_array_equal(result.values, func(df1.values, df2.values))
msg = (
"Unable to coerce to Series/DataFrame, "
"dimension must be <= 2: (30, 4, 1, 1, 1)"
)
with pytest.raises(ValueError, match=re.escape(msg)):
func(df1, ndim_5)
result2 = func(simple_frame, row)
tm.assert_numpy_array_equal(
result2.values, func(simple_frame.values, row.values)
)
result3 = func(float_frame, 0)
tm.assert_numpy_array_equal(result3.values, func(float_frame.values, 0))
msg = "Can only compare identically-labeled DataFrame"
with pytest.raises(ValueError, match=msg):
func(simple_frame, simple_frame[:2])
test_comp(operator.eq)
test_comp(operator.ne)
test_comp(operator.lt)
test_comp(operator.gt)
test_comp(operator.ge)
test_comp(operator.le)
def test_strings_to_numbers_comparisons_raises(self, compare_operators_no_eq_ne):
# GH 11565
df = DataFrame(
{x: {"x": "foo", "y": "bar", "z": "baz"} for x in ["a", "b", "c"]}
)
f = getattr(operator, compare_operators_no_eq_ne)
msg = "'[<>]=?' not supported between instances of 'str' and 'int'"
with pytest.raises(TypeError, match=msg):
f(df, 0)
def test_comparison_protected_from_errstate(self):
missing_df = tm.makeDataFrame()
missing_df.iloc[0]["A"] = np.nan
with np.errstate(invalid="ignore"):
expected = missing_df.values < 0
with np.errstate(invalid="raise"):
result = (missing_df < 0).values
tm.assert_numpy_array_equal(result, expected)
def test_boolean_comparison(self):
# GH 4576
# boolean comparisons with a tuple/list give unexpected results
df = DataFrame(np.arange(6).reshape((3, 2)))
b = np.array([2, 2])
b_r = np.atleast_2d([2, 2])
b_c = b_r.T
lst = [2, 2, 2]
tup = tuple(lst)
# gt
expected = DataFrame([[False, False], [False, True], [True, True]])
result = df > b
tm.assert_frame_equal(result, expected)
result = df.values > b
tm.assert_numpy_array_equal(result, expected.values)
msg1d = "Unable to coerce to Series, length must be 2: given 3"
msg2d = "Unable to coerce to DataFrame, shape must be"
msg2db = "operands could not be broadcast together with shapes"
with pytest.raises(ValueError, match=msg1d):
# wrong shape
df > lst
with pytest.raises(ValueError, match=msg1d):
# wrong shape
result = df > tup
# broadcasts like ndarray (GH#23000)
result = df > b_r
tm.assert_frame_equal(result, expected)
result = df.values > b_r
tm.assert_numpy_array_equal(result, expected.values)
with pytest.raises(ValueError, match=msg2d):
df > b_c
with pytest.raises(ValueError, match=msg2db):
df.values > b_c
# ==
expected = DataFrame([[False, False], [True, False], [False, False]])
result = df == b
tm.assert_frame_equal(result, expected)
with pytest.raises(ValueError, match=msg1d):
result = df == lst
with pytest.raises(ValueError, match=msg1d):
result = df == tup
# broadcasts like ndarray (GH#23000)
result = df == b_r
tm.assert_frame_equal(result, expected)
result = df.values == b_r
tm.assert_numpy_array_equal(result, expected.values)
with pytest.raises(ValueError, match=msg2d):
df == b_c
assert df.values.shape != b_c.shape
# with alignment
df = DataFrame(
np.arange(6).reshape((3, 2)), columns=list("AB"), index=list("abc")
)
expected.index = df.index
expected.columns = df.columns
with pytest.raises(ValueError, match=msg1d):
result = df == lst
with pytest.raises(ValueError, match=msg1d):
result = df == tup
def test_inplace_ops_alignment(self):
# inplace ops / ops alignment
# GH 8511
columns = list("abcdefg")
X_orig = DataFrame(
np.arange(10 * len(columns)).reshape(-1, len(columns)),
columns=columns,
index=range(10),
)
Z = 100 * X_orig.iloc[:, 1:-1].copy()
block1 = list("bedcf")
subs = list("bcdef")
# add
X = X_orig.copy()
result1 = (X[block1] + Z).reindex(columns=subs)
X[block1] += Z
result2 = X.reindex(columns=subs)
X = X_orig.copy()
result3 = (X[block1] + Z[block1]).reindex(columns=subs)
X[block1] += Z[block1]
result4 = X.reindex(columns=subs)
tm.assert_frame_equal(result1, result2)
tm.assert_frame_equal(result1, result3)
tm.assert_frame_equal(result1, result4)
# sub
X = X_orig.copy()
result1 = (X[block1] - Z).reindex(columns=subs)
X[block1] -= Z
result2 = X.reindex(columns=subs)
X = X_orig.copy()
result3 = (X[block1] - Z[block1]).reindex(columns=subs)
X[block1] -= Z[block1]
result4 = X.reindex(columns=subs)
tm.assert_frame_equal(result1, result2)
tm.assert_frame_equal(result1, result3)
tm.assert_frame_equal(result1, result4)
def test_inplace_ops_identity(self):
# GH 5104
# make sure that we are actually changing the object
s_orig = Series([1, 2, 3])
df_orig = DataFrame(np.random.randint(0, 5, size=10).reshape(-1, 5))
# no dtype change
s = s_orig.copy()
s2 = s
s += 1
tm.assert_series_equal(s, s2)
tm.assert_series_equal(s_orig + 1, s)
assert s is s2
assert s._mgr is s2._mgr
df = df_orig.copy()
df2 = df
df += 1
tm.assert_frame_equal(df, df2)
tm.assert_frame_equal(df_orig + 1, df)
assert df is df2
assert df._mgr is df2._mgr
# dtype change
s = s_orig.copy()
s2 = s
s += 1.5
tm.assert_series_equal(s, s2)
tm.assert_series_equal(s_orig + 1.5, s)
df = df_orig.copy()
df2 = df
df += 1.5
tm.assert_frame_equal(df, df2)
tm.assert_frame_equal(df_orig + 1.5, df)
assert df is df2
assert df._mgr is df2._mgr
# mixed dtype
arr = np.random.randint(0, 10, size=5)
df_orig = DataFrame({"A": arr.copy(), "B": "foo"})
df = df_orig.copy()
df2 = df
df["A"] += 1
expected = DataFrame({"A": arr.copy() + 1, "B": "foo"})
tm.assert_frame_equal(df, expected)
tm.assert_frame_equal(df2, expected)
assert df._mgr is df2._mgr
df = df_orig.copy()
df2 = df
df["A"] += 1.5
expected = DataFrame({"A": arr.copy() + 1.5, "B": "foo"})
tm.assert_frame_equal(df, expected)
tm.assert_frame_equal(df2, expected)
assert df._mgr is df2._mgr
@pytest.mark.parametrize(
"op",
[
"add",
"and",
"div",
"floordiv",
"mod",
"mul",
"or",
"pow",
"sub",
"truediv",
"xor",
],
)
def test_inplace_ops_identity2(self, op):
if op == "div":
return
df = DataFrame({"a": [1.0, 2.0, 3.0], "b": [1, 2, 3]})
operand = 2
if op in ("and", "or", "xor"):
# cannot use floats for boolean ops
df["a"] = [True, False, True]
df_copy = df.copy()
iop = f"__i{op}__"
op = f"__{op}__"
# no id change and value is correct
getattr(df, iop)(operand)
expected = getattr(df_copy, op)(operand)
tm.assert_frame_equal(df, expected)
expected = id(df)
assert id(df) == expected
def test_alignment_non_pandas(self):
index = ["A", "B", "C"]
columns = ["X", "Y", "Z"]
df = pd.DataFrame(np.random.randn(3, 3), index=index, columns=columns)
align = pd.core.ops.align_method_FRAME
for val in [
[1, 2, 3],
(1, 2, 3),
np.array([1, 2, 3], dtype=np.int64),
range(1, 4),
]:
expected = DataFrame({"X": val, "Y": val, "Z": val}, index=df.index)
tm.assert_frame_equal(align(df, val, "index")[1], expected)
expected = DataFrame(
{"X": [1, 1, 1], "Y": [2, 2, 2], "Z": [3, 3, 3]}, index=df.index
)
tm.assert_frame_equal(align(df, val, "columns")[1], expected)
# length mismatch
msg = "Unable to coerce to Series, length must be 3: given 2"
for val in [[1, 2], (1, 2), np.array([1, 2]), range(1, 3)]:
with pytest.raises(ValueError, match=msg):
align(df, val, "index")
with pytest.raises(ValueError, match=msg):
align(df, val, "columns")
val = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
tm.assert_frame_equal(
align(df, val, "index")[1],
DataFrame(val, index=df.index, columns=df.columns),
)
tm.assert_frame_equal(
align(df, val, "columns")[1],
DataFrame(val, index=df.index, columns=df.columns),
)
# shape mismatch
msg = "Unable to coerce to DataFrame, shape must be"
val = np.array([[1, 2, 3], [4, 5, 6]])
with pytest.raises(ValueError, match=msg):
align(df, val, "index")
with pytest.raises(ValueError, match=msg):
align(df, val, "columns")
val = np.zeros((3, 3, 3))
msg = re.escape(
"Unable to coerce to Series/DataFrame, dimension must be <= 2: (3, 3, 3)"
)
with pytest.raises(ValueError, match=msg):
align(df, val, "index")
with pytest.raises(ValueError, match=msg):
align(df, val, "columns")
def test_no_warning(self, all_arithmetic_operators):
df = pd.DataFrame({"A": [0.0, 0.0], "B": [0.0, None]})
b = df["B"]
with tm.assert_produces_warning(None):
getattr(df, all_arithmetic_operators)(b, 0)
def test_pow_with_realignment():
# GH#32685 pow has special semantics for operating with null values
left = pd.DataFrame({"A": [0, 1, 2]})
right = pd.DataFrame(index=[0, 1, 2])
result = left ** right
expected = pd.DataFrame({"A": [np.nan, 1.0, np.nan]})
tm.assert_frame_equal(result, expected)
# TODO: move to tests.arithmetic and parametrize
def test_pow_nan_with_zero():
left = pd.DataFrame({"A": [np.nan, np.nan, np.nan]})
right = pd.DataFrame({"A": [0, 0, 0]})
expected = pd.DataFrame({"A": [1.0, 1.0, 1.0]})
result = left ** right
tm.assert_frame_equal(result, expected)
result = left["A"] ** right["A"]
tm.assert_series_equal(result, expected["A"])
def test_dataframe_series_extension_dtypes():
# https://github.com/pandas-dev/pandas/issues/34311
df = pd.DataFrame(np.random.randint(0, 100, (10, 3)), columns=["a", "b", "c"])
ser = pd.Series([1, 2, 3], index=["a", "b", "c"])
expected = df.to_numpy("int64") + ser.to_numpy("int64").reshape(-1, 3)
expected = pd.DataFrame(expected, columns=df.columns, dtype="Int64")
df_ea = df.astype("Int64")
result = df_ea + ser
tm.assert_frame_equal(result, expected)
result = df_ea + ser.astype("Int64")
tm.assert_frame_equal(result, expected)
def test_dataframe_blockwise_slicelike():
# GH#34367
arr = np.random.randint(0, 1000, (100, 10))
df1 = pd.DataFrame(arr)
df2 = df1.copy()
df2.iloc[0, [1, 3, 7]] = np.nan
df3 = df1.copy()
df3.iloc[0, [5]] = np.nan
df4 = df1.copy()
df4.iloc[0, np.arange(2, 5)] = np.nan
df5 = df1.copy()
df5.iloc[0, np.arange(4, 7)] = np.nan
for left, right in [(df1, df2), (df2, df3), (df4, df5)]:
res = left + right
expected = pd.DataFrame({i: left[i] + right[i] for i in left.columns})
tm.assert_frame_equal(res, expected)
@pytest.mark.parametrize(
"df, col_dtype",
[
(pd.DataFrame([[1.0, 2.0], [4.0, 5.0]], columns=list("ab")), "float64"),
(pd.DataFrame([[1.0, "b"], [4.0, "b"]], columns=list("ab")), "object"),
],
)
def test_dataframe_operation_with_non_numeric_types(df, col_dtype):
# GH #22663
expected = pd.DataFrame([[0.0, np.nan], [3.0, np.nan]], columns=list("ab"))
expected = expected.astype({"b": col_dtype})
result = df + pd.Series([-1.0], index=list("a"))
tm.assert_frame_equal(result, expected)
def test_arith_reindex_with_duplicates():
# https://github.com/pandas-dev/pandas/issues/35194
df1 = pd.DataFrame(data=[[0]], columns=["second"])
df2 = pd.DataFrame(data=[[0, 0, 0]], columns=["first", "second", "second"])
result = df1 + df2
expected = pd.DataFrame([[np.nan, 0, 0]], columns=["first", "second", "second"])
tm.assert_frame_equal(result, expected)
| bsd-3-clause |
fzalkow/scikit-learn | sklearn/metrics/metrics.py | 233 | 1262 | import warnings
warnings.warn("sklearn.metrics.metrics is deprecated and will be removed in "
"0.18. Please import from sklearn.metrics",
DeprecationWarning)
from .ranking import auc
from .ranking import average_precision_score
from .ranking import label_ranking_average_precision_score
from .ranking import precision_recall_curve
from .ranking import roc_auc_score
from .ranking import roc_curve
from .classification import accuracy_score
from .classification import classification_report
from .classification import confusion_matrix
from .classification import f1_score
from .classification import fbeta_score
from .classification import hamming_loss
from .classification import hinge_loss
from .classification import jaccard_similarity_score
from .classification import log_loss
from .classification import matthews_corrcoef
from .classification import precision_recall_fscore_support
from .classification import precision_score
from .classification import recall_score
from .classification import zero_one_loss
from .regression import explained_variance_score
from .regression import mean_absolute_error
from .regression import mean_squared_error
from .regression import median_absolute_error
from .regression import r2_score
| bsd-3-clause |
keans/dstools | dstools/roc.py | 1 | 4089 | import logging
import ujson as json
import numpy as np
from sklearn.metrics import roc_curve, auc
import matplotlib.pyplot as plt
from matplotlib import ticker
from .plot import FigureContext
# disable extensive matplotlib logging
logging.getLogger("matplotlib").setLevel(logging.WARNING)
# logger
log = logging.getLogger(__name__)
class RocCurve:
"""
class that abstracts some of the logic of the
Receiver Operating Characteristics (ROC) curve
"""
def __init__(self, labels=None, scores=None, name="ROC"):
self._name = name
if (labels is not None) and (scores is not None):
# compute roc curve, if provided
assert(len(labels) == len(scores))
self.compute_roc_curve(labels, scores)
def compute_roc_curve(self, labels, scores):
"""
compute the ROC curve for given labels and scores
"""
self._fpr, self._tpr, self._thresholds = roc_curve(labels, scores)
@property
def dict(self):
return {
"name": self._name,
"fpr": self._fpr,
"tpr": self._tpr,
}
def set_name(self, name):
"""
set new name
"""
self._name = name
def auc(self, max_fpr=1.0):
"""
compute (bounded-)AUC for ROC curve
"""
return self._bounded_auc(self._fpr, self._tpr, max_fpr)
def _bounded_auc(self, fpr, tpr, max_fpr=None):
"""
compute the bounded AUC of a ROC curve on given
false positive rate and true positive rate
"""
if (max_fpr is None) or (max_fpr == 1.0):
# just return full auc i.e. without modifications
return fpr, tpr, auc(fpr, tpr)
# compute bounded auc
stop = np.searchsorted(fpr, max_fpr, "right")
x_interp = [fpr[stop - 1], fpr[stop]]
y_interp = [tpr[stop - 1], tpr[stop]]
tpr = np.append(tpr[:stop], np.interp(max_fpr, x_interp, y_interp))
fpr = np.append(fpr[:stop], max_fpr)
# McClish correction: standardize result to be 0.5,
# if non-discriminant and 1 if maximal
min_area = 0.5 * max_fpr ** 2
auc_ = 0.5 * (1 + (auc(fpr, tpr) - min_area) / (max_fpr - min_area))
return fpr, tpr, auc_
def plot(self, ax, max_fpr=1.0, title=None, random_line=True):
# plot ROC curve
ax.plot(self._fpr, self._tpr, label=self._name)
# plot random predictions line
if random_line is True:
plt.plot([0, 1], [0, 1], "k--")
ax.xaxis.set_major_locator(ticker.MaxNLocator(prune='lower'))
plt.xlim([0.0, max_fpr or 1.0])
plt.ylim([0.0, 1.0])
if title is not None:
plt.title(title)
plt.legend(loc="lower right")
def save(self, filename):
"""
save given ROC curve as .json file
"""
log.debug("saving ROC curve to '{}'...".format(filename))
with open(filename, "w") as f:
json.dump(self.dict, f)
def load(self, filename):
"""
save given ROC curve as .json file
"""
log.debug("loading ROC curve from '{}'...".format(filename))
with open(filename, "r") as f:
d = json.load(f)
self._fpr = d["fpr"]
self._tpr = d["tpr"]
self._name = d["name"]
def plot_rocs(
rocs, targetdir, filename="roc", max_fpr=None, random_line=True,
title=None, figsize=(10, 8), ext="pdf"
):
"""
plot multiple ROC curves into one figure
list of rocs must contain dictionaries with the following keys:
"fpr", "tpr", "auc_score", "label"
"""
if isinstance(rocs, RocCurve):
# convert single roc dict into list
rocs = [rocs]
with FigureContext(
targetdir=targetdir, filename=filename, title=title,
xlabel="False Positive Rate", ylabel="True Positive Rate",
rotate_xticks=False, ext=ext, figsize=figsize
) as ax:
for roc in rocs:
roc.plot(ax, max_fpr, title, random_line)
return plt.gcf()
| mit |
amacd31/dice-counter | run.py | 1 | 3868 | """
Copyright (C) 2014 Andrew MacDonald
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
"""
import argparse
import datetime
import json
from matplotlib import pyplot as plt
import numpy as np
class DieCounter(object):
def __init__(self, savefile):
self.savefile = savefile
fig=plt.figure()
self.ax1 = plt.subplot(2,1,1)
self.ax2 = plt.subplot(2,2,3)
self.ax3 = plt.subplot(2,2,4)
self.ax1.set_xlim([2,13])
self.ax2.set_xlim([1,7])
self.ax3.set_xlim([1,7])
plt.ion()
plt.show()
def get_ans(self):
answer = raw_input().lower()
if answer == 'quit':
print 'You quit!'
self.save()
exit()
elif answer == 'save':
self.save()
elif answer == 'undo':
print "Removed roll %d, %d" % (self.d1_list.pop(), self.d2_list.pop())
print "Last roll now %d, %d" % (self.d1_list[-1], self.d2_list[-1])
try:
answer = int(answer)
except:
print "%s was not a number" % answer
return self.get_ans()
if answer in [1,2,3,4,5,6]:
return answer
else:
print "%d not between 1 and 6" % answer
return self.get_ans()
def save(self):
print 'Saving to %s...' % self.savefile
json.dump({'d1': self.d1_list, 'd2': self.d2_list}, open(self.savefile, 'w'))
print 'Saved.'
def update_plot(self):
bins = np.arange(2, 14, 1)
sub_plot_bins = np.arange(1, 8, 1)
self.ax1.cla()
self.ax2.cla()
self.ax3.cla()
self.ax1.set_xlim([1.5,12.5])
self.ax2.set_xlim([0.5,6.5])
self.ax3.set_xlim([0.5,6.5])
self.ax1.hist(np.array(self.d1_list) + np.array(self.d2_list), bins=bins, range=[1,13], facecolor='g', align='left')
self.ax1.set_xticks(bins[:-1])
self.ax2.hist(np.array(self.d1_list), bins=sub_plot_bins, range=[1,7], facecolor='g', align='left')
self.ax2.set_xticks(sub_plot_bins[:-1])
self.ax3.hist(np.array(self.d2_list), bins=sub_plot_bins, range=[1,7], facecolor='g', align='left')
self.ax3.set_xticks(sub_plot_bins[:-1])
plt.draw()
def start(self):
self.d1_list = []
self.d2_list = []
print "Die 1:"
d1 = counter.get_ans()
print "Die 2:"
d2 = counter.get_ans()
while(1):
self.d1_list.append(d1)
self.d2_list.append(d2)
print "Last roll:", self.d1_list[-1], self.d2_list[-1]
counter.update_plot()
print "Die 1:"
d1 = counter.get_ans()
print "Die 2:"
d2 = counter.get_ans()
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Counts dice rolls.')
parser.add_argument('savefile', metavar='FILE', type=str, nargs='?', default=datetime.datetime.now().strftime('%Y%m%d_%H%M_rolls.json'),
help='File to save results to when quitting. Default: YYYYMMDD_HHMM_rolls.json')
args = parser.parse_args()
counter = DieCounter(args.savefile)
counter.start()
| gpl-2.0 |
irhete/predictive-monitoring-benchmark | experiments/experiments_knn.py | 1 | 11024 | import EncoderFactory
from DatasetManager import DatasetManager
import BucketFactory
import pandas as pd
import numpy as np
from sklearn.metrics import roc_auc_score
from sklearn.pipeline import FeatureUnion, Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import NearestNeighbors
import time
import os
import sys
from sys import argv
import pickle
from collections import defaultdict
from sklearn.ensemble import RandomForestClassifier
import xgboost as xgb
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
dataset_ref = argv[1]
params_dir = argv[2]
results_dir = argv[3]
bucket_method = argv[4]
cls_encoding = argv[5]
cls_method = argv[6]
gap = int(argv[7])
n_iter = int(argv[8])
if bucket_method == "state":
bucket_encoding = "last"
else:
bucket_encoding = "agg"
method_name = "%s_%s"%(bucket_method, cls_encoding)
dataset_ref_to_datasets = {
"bpic2011": ["bpic2011_f%s"%formula for formula in range(1,5)],
"bpic2015": ["bpic2015_%s_f2"%(municipality) for municipality in range(1,6)],
"insurance": ["insurance_activity", "insurance_followup"],
"sepsis_cases": ["sepsis_cases_1", "sepsis_cases_2", "sepsis_cases_4"]
}
encoding_dict = {
"laststate": ["static", "last"],
"agg": ["static", "agg"],
"index": ["static", "index"],
"combined": ["static", "last", "agg"]
}
datasets = [dataset_ref] if dataset_ref not in dataset_ref_to_datasets else dataset_ref_to_datasets[dataset_ref]
methods = encoding_dict[cls_encoding]
train_ratio = 0.8
random_state = 22
# create results directory
if not os.path.exists(os.path.join(params_dir)):
os.makedirs(os.path.join(params_dir))
for dataset_name in datasets:
# load optimal params
optimal_params_filename = os.path.join(params_dir, "optimal_params_%s_%s_%s.pickle" % (cls_method, dataset_name, method_name))
if not os.path.isfile(optimal_params_filename) or os.path.getsize(optimal_params_filename) <= 0:
continue
with open(optimal_params_filename, "rb") as fin:
args = pickle.load(fin)
# read the data
dataset_manager = DatasetManager(dataset_name)
data = dataset_manager.read_dataset()
cls_encoder_args = {'case_id_col': dataset_manager.case_id_col,
'static_cat_cols': dataset_manager.static_cat_cols,
'static_num_cols': dataset_manager.static_num_cols,
'dynamic_cat_cols': dataset_manager.dynamic_cat_cols,
'dynamic_num_cols': dataset_manager.dynamic_num_cols,
'fillna': True}
# determine min and max (truncated) prefix lengths
min_prefix_length = 1
if "traffic_fines" in dataset_name:
max_prefix_length = 10
elif "bpic2017" in dataset_name:
max_prefix_length = min(20, dataset_manager.get_pos_case_length_quantile(data, 0.90))
else:
max_prefix_length = min(40, dataset_manager.get_pos_case_length_quantile(data, 0.90))
# split into training and test
train, test = dataset_manager.split_data_strict(data, train_ratio, split="temporal")
if gap > 1:
outfile = os.path.join(results_dir, "performance_results_%s_%s_%s_gap%s.csv" % (cls_method, dataset_name, method_name, gap))
else:
outfile = os.path.join(results_dir, "performance_results_%s_%s_%s.csv" % (cls_method, dataset_name, method_name))
start_test_prefix_generation = time.time()
dt_test_prefixes = dataset_manager.generate_prefix_data(test, min_prefix_length, max_prefix_length)
test_prefix_generation_time = time.time() - start_test_prefix_generation
offline_total_times = []
online_event_times = []
train_prefix_generation_times = []
for ii in range(n_iter):
# create prefix logs
start_train_prefix_generation = time.time()
dt_train_prefixes = dataset_manager.generate_prefix_data(train, min_prefix_length, max_prefix_length, gap)
train_prefix_generation_time = time.time() - start_train_prefix_generation
train_prefix_generation_times.append(train_prefix_generation_time)
# Bucketing prefixes based on control flow
knn_encoder_args = {'case_id_col':dataset_manager.case_id_col,
'static_cat_cols':[],
'static_num_cols':[],
'dynamic_cat_cols':[dataset_manager.activity_col],
'dynamic_num_cols':[],
'fillna':True}
# initiate the KNN model
start_offline_time_bucket = time.time()
bucket_encoder = EncoderFactory.get_encoder(bucket_encoding, **knn_encoder_args)
encoded_train = bucket_encoder.fit_transform(dt_train_prefixes)
if "n_neighbors" in args:
n_neighbors = int(args["n_neighbors"])
else:
n_neighbors = 50
bucketer = NearestNeighbors(n_neighbors=n_neighbors, algorithm='auto').fit(encoded_train)
offline_time_bucket = time.time() - start_offline_time_bucket
preds_all = []
test_y_all = []
nr_events_all = []
offline_time_fit = 0
current_online_event_times = []
for _, dt_test_bucket in dt_test_prefixes.groupby(dataset_manager.case_id_col):
# select current test case
test_y_all.extend(dataset_manager.get_label_numeric(dt_test_bucket))
nr_events_all.append(len(dt_test_bucket))
start = time.time()
encoded_case = bucket_encoder.fit_transform(dt_test_bucket)
_, knn_idxs = bucketer.kneighbors(encoded_case)
knn_idxs = knn_idxs[0]
relevant_cases_bucket = encoded_train.iloc[knn_idxs].index
dt_train_bucket = dataset_manager.get_relevant_data_by_indexes(dt_train_prefixes, relevant_cases_bucket) # one row per event
train_y = dataset_manager.get_label_numeric(dt_train_bucket)
if len(set(train_y)) < 2:
preds_all.append(train_y[0])
else:
feature_combiner = FeatureUnion([(method, EncoderFactory.get_encoder(method, **cls_encoder_args)) for method in methods])
if cls_method == "rf":
cls = RandomForestClassifier(n_estimators=500,
max_features=args['max_features'],
random_state=random_state)
elif cls_method == "xgboost":
cls = xgb.XGBClassifier(objective='binary:logistic',
n_estimators=500,
learning_rate= args['learning_rate'],
subsample=args['subsample'],
max_depth=int(args['max_depth']),
colsample_bytree=args['colsample_bytree'],
min_child_weight=int(args['min_child_weight']),
seed=random_state)
elif cls_method == "logit":
cls = LogisticRegression(C=2**args['C'],
random_state=random_state)
elif cls_method == "svm":
cls = SVC(C=2**args['C'],
gamma=2**args['gamma'],
random_state=random_state)
if cls_method == "svm" or cls_method == "logit":
pipeline = Pipeline([('encoder', feature_combiner), ('scaler', StandardScaler()), ('cls', cls)])
else:
pipeline = Pipeline([('encoder', feature_combiner), ('cls', cls)])
pipeline.fit(dt_train_bucket, train_y)
if cls_method == "svm":
preds = pipeline.decision_function(dt_test_bucket)
else:
preds_pos_label_idx = np.where(cls.classes_ == 1)[0][0]
preds = pipeline.predict_proba(dt_test_bucket)[:,preds_pos_label_idx]
preds_all.extend(preds)
pipeline_pred_time = time.time() - start
current_online_event_times.append(pipeline_pred_time / len(dt_test_bucket))
offline_total_time = offline_time_bucket + train_prefix_generation_time
offline_total_times.append(offline_total_time)
online_event_times.append(current_online_event_times)
with open(outfile, 'w') as fout:
fout.write("%s;%s;%s;%s;%s;%s;%s\n"%("dataset", "method", "cls", "nr_events", "n_iter", "metric", "score"))
fout.write("%s;%s;%s;%s;%s;%s;%s\n"%(dataset_name, method_name, cls_method, -1, -1, "test_prefix_generation_time", test_prefix_generation_time))
for ii in range(len(offline_total_times)):
fout.write("%s;%s;%s;%s;%s;%s;%s\n"%(dataset_name, method_name, cls_method, -1, ii, "train_prefix_generation_time", train_prefix_generation_times[ii]))
fout.write("%s;%s;%s;%s;%s;%s;%s\n"%(dataset_name, method_name, cls_method, -1, ii, "offline_time_total", offline_total_times[ii]))
fout.write("%s;%s;%s;%s;%s;%s;%s\n"%(dataset_name, method_name, cls_method, -1, ii, "online_time_avg", np.mean(online_event_times[ii])))
fout.write("%s;%s;%s;%s;%s;%s;%s\n"%(dataset_name, method_name, cls_method, -1, ii, "online_time_std", np.std(online_event_times[ii])))
dt_results = pd.DataFrame({"actual": test_y_all, "predicted": preds_all, "nr_events": nr_events_all})
for nr_events, group in dt_results.groupby("nr_events"):
if len(set(group.actual)) < 2:
fout.write("%s;%s;%s;%s;%s;%s;%s\n"%(dataset_name, method_name, cls_method, nr_events, -1, "auc", np.nan))
else:
fout.write("%s;%s;%s;%s;%s;%s;%s\n"%(dataset_name, method_name, cls_method, nr_events, -1, "auc", roc_auc_score(group.actual, group.predicted)))
fout.write("%s;%s;%s;%s;%s;%s;%s\n"%(dataset_name, method_name, cls_method, -1, -1, "auc", roc_auc_score(dt_results.actual, dt_results.predicted)))
online_event_times_flat = [t for iter_online_event_times in online_event_times for t in iter_online_event_times]
fout.write("%s;%s;%s;%s;%s;%s;%s\n"%(dataset_name, method_name, cls_method, -1, -1, "online_time_avg", np.mean(online_event_times_flat)))
fout.write("%s;%s;%s;%s;%s;%s;%s\n"%(dataset_name, method_name, cls_method, -1, -1, "online_time_std", np.std(online_event_times_flat)))
fout.write("%s;%s;%s;%s;%s;%s;%s\n"%(dataset_name, method_name, cls_method, -1, -1, "offline_time_total_avg", np.mean(offline_total_times)))
fout.write("%s;%s;%s;%s;%s;%s;%s\n"%(dataset_name, method_name, cls_method, -1, -1, "offline_time_total_std", np.std(offline_total_times))) | apache-2.0 |
zycdragonball/tensorflow | tensorflow/contrib/labeled_tensor/python/ops/ops.py | 77 | 46403 | # Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Non-core ops for LabeledTensor."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import collections
import types
import numpy as np
from six import string_types
from tensorflow.contrib.labeled_tensor.python.ops import _typecheck as tc
from tensorflow.contrib.labeled_tensor.python.ops import core
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import ops
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import functional_ops
from tensorflow.python.ops import math_ops
from tensorflow.python.ops import numerics
from tensorflow.python.ops import random_ops
from tensorflow.python.training import input # pylint: disable=redefined-builtin
@tc.returns(core.LabeledTensor)
@tc.accepts(core.LabeledTensor, ops.Tensor, core.Axis,
tc.Optional(string_types))
def _gather_1d_on_axis(labeled_tensor, indexer, axis, name=None):
with ops.name_scope(name, 'lt_take', [labeled_tensor]) as scope:
temp_axes = core.Axes([axis] + list(
labeled_tensor.axes.remove(axis.name).values()))
transposed = core.transpose(labeled_tensor, temp_axes.keys())
indexed = core.LabeledTensor(
array_ops.gather(transposed.tensor, indexer), temp_axes)
return core.transpose(indexed, labeled_tensor.axes.keys(), name=scope)
@tc.returns(core.LabeledTensor)
@tc.accepts(core.LabeledTensorLike,
tc.Mapping(string_types,
tc.Union(slice, collections.Hashable, list)),
tc.Optional(string_types))
def select(labeled_tensor, selection, name=None):
"""Slice out a subset of the tensor.
Args:
labeled_tensor: The input tensor.
selection: A dictionary mapping an axis name to a scalar, slice or list of
values to select. Currently supports two types of selections:
(a) Any number of scalar and/or slice selections.
(b) Exactly one list selection, without any scalars or slices.
name: Optional op name.
Returns:
The selection as a `LabeledTensor`.
Raises:
ValueError: If the tensor doesn't have an axis in the selection or if
that axis lacks labels.
KeyError: If any labels in a selection are not found in the original axis.
NotImplementedError: If you attempt to combine a list selection with
scalar selection or another list selection.
"""
with ops.name_scope(name, 'lt_select', [labeled_tensor]) as scope:
labeled_tensor = core.convert_to_labeled_tensor(labeled_tensor)
slices = {}
indexers = {}
for axis_name, value in selection.items():
if axis_name not in labeled_tensor.axes:
raise ValueError(
'The tensor does not have an axis named %s. Its axes are: %r' %
(axis_name, labeled_tensor.axes.keys()))
axis = labeled_tensor.axes[axis_name]
if axis.labels is None:
raise ValueError(
'The axis named %s does not have labels. The axis is: %r' %
(axis_name, axis))
if isinstance(value, slice):
# TODO(shoyer): consider deprecating using slices in favor of lists
if value.start is None:
start = None
else:
start = axis.index(value.start)
if value.stop is None:
stop = None
else:
# For now, follow the pandas convention of making labeled slices
# inclusive of both bounds.
stop = axis.index(value.stop) + 1
if value.step is not None:
raise NotImplementedError('slicing with a step is not yet supported')
slices[axis_name] = slice(start, stop)
# Needs to be after checking for slices, since slice objects claim to be
# instances of collections.Hashable but hash() on them fails.
elif isinstance(value, collections.Hashable):
slices[axis_name] = axis.index(value)
elif isinstance(value, list):
if indexers:
raise NotImplementedError(
'select does not yet support more than one list selection at '
'the same time')
indexer = [axis.index(v) for v in value]
indexers[axis_name] = ops.convert_to_tensor(indexer, dtype=dtypes.int64)
else:
# If type checking is working properly, this shouldn't be possible.
raise TypeError('cannot handle arbitrary types')
if indexers and slices:
raise NotImplementedError(
'select does not yet support combined scalar and list selection')
# For now, handle array selection separately, because tf.gather_nd does
# not support gradients yet. Later, using gather_nd will let us combine
# these paths.
if indexers:
(axis_name, indexer), = indexers.items()
axis = core.Axis(axis_name, selection[axis_name])
return _gather_1d_on_axis(labeled_tensor, indexer, axis, name=scope)
else:
return core.slice_function(labeled_tensor, slices, name=scope)
@tc.returns(core.LabeledTensor)
@tc.accepts(
tc.Collection(core.LabeledTensorLike), string_types,
tc.Optional(string_types))
def concat(labeled_tensors, axis_name, name=None):
"""Concatenate tensors along a dimension.
See tf.concat.
Args:
labeled_tensors: A list of input LabeledTensors.
axis_name: The name of the axis along which to concatenate.
name: Optional op name.
Returns:
The concatenated tensor.
The coordinate labels for the concatenation dimension are also concatenated,
if they are available for every tensor.
Raises:
ValueError: If fewer than one tensor inputs is provided, if the tensors
have incompatible axes, or if `axis_name` isn't the name of an axis.
"""
with ops.name_scope(name, 'lt_concat', labeled_tensors) as scope:
labeled_tensors = [
core.convert_to_labeled_tensor(lt) for lt in labeled_tensors
]
if len(labeled_tensors) < 1:
raise ValueError('concat expects at least 1 tensor, but received %s' %
labeled_tensors)
# All tensors must have these axes.
axes_0 = labeled_tensors[0].axes
axis_names = list(axes_0.keys())
if axis_name not in axis_names:
raise ValueError('%s not in %s' % (axis_name, axis_names))
shared_axes = axes_0.remove(axis_name)
tensors = [labeled_tensors[0].tensor]
concat_axis_list = [axes_0[axis_name]]
for labeled_tensor in labeled_tensors[1:]:
current_shared_axes = labeled_tensor.axes.remove(axis_name)
if current_shared_axes != shared_axes:
# TODO(shoyer): add more specific checks about what went wrong,
# including raising AxisOrderError when appropriate
raise ValueError('Mismatched shared axes: the first tensor '
'had axes %r but this tensor has axes %r.' %
(shared_axes, current_shared_axes))
# Accumulate the axis labels, if they're available.
concat_axis_list.append(labeled_tensor.axes[axis_name])
tensors.append(labeled_tensor.tensor)
concat_axis = core.concat_axes(concat_axis_list)
concat_dimension = axis_names.index(axis_name)
concat_tensor = array_ops.concat(tensors, concat_dimension, name=scope)
values = list(axes_0.values())
concat_axes = (values[:concat_dimension] + [concat_axis] +
values[concat_dimension + 1:])
return core.LabeledTensor(concat_tensor, concat_axes)
# TODO(shoyer): rename pack/unpack to stack/unstack
@tc.returns(core.LabeledTensor)
@tc.accepts(
tc.Collection(core.LabeledTensorLike),
tc.Union(string_types, core.AxisLike), int, tc.Optional(string_types))
def pack(labeled_tensors, new_axis, axis_position=0, name=None):
"""Pack tensors along a new axis.
See tf.pack.
Args:
labeled_tensors: The input tensors, which must have identical axes.
new_axis: The name of the new axis, or a tuple containing the name
and coordinate labels.
axis_position: Optional integer position at which to insert the new axis.
name: Optional op name.
Returns:
The packed tensors as a single LabeledTensor, with `new_axis` in the given
`axis_position`.
Raises:
ValueError: If fewer than one input tensors is provided, or if the tensors
don't have identical axes.
"""
with ops.name_scope(name, 'lt_pack', labeled_tensors) as scope:
labeled_tensors = [
core.convert_to_labeled_tensor(lt) for lt in labeled_tensors
]
if len(labeled_tensors) < 1:
raise ValueError('pack expects at least 1 tensors, but received %s' %
labeled_tensors)
axes_0 = labeled_tensors[0].axes
for t in labeled_tensors:
if t.axes != axes_0:
raise ValueError('Non-identical axes. Expected %s but got %s' %
(axes_0, t.axes))
pack_op = array_ops.stack(
[t.tensor for t in labeled_tensors], axis=axis_position, name=scope)
axes = list(axes_0.values())
axes.insert(axis_position, new_axis)
return core.LabeledTensor(pack_op, axes)
@tc.returns(tc.List(core.LabeledTensor))
@tc.accepts(core.LabeledTensorLike,
tc.Optional(string_types), tc.Optional(string_types))
def unpack(labeled_tensor, axis_name=None, name=None):
"""Unpack the tensor.
See tf.unpack.
Args:
labeled_tensor: The input tensor.
axis_name: Optional name of axis to unpack. By default, the first axis is
used.
name: Optional op name.
Returns:
The list of unpacked LabeledTensors.
Raises:
ValueError: If `axis_name` is not an axis on the input.
"""
with ops.name_scope(name, 'lt_unpack', [labeled_tensor]) as scope:
labeled_tensor = core.convert_to_labeled_tensor(labeled_tensor)
axis_names = list(labeled_tensor.axes.keys())
if axis_name is None:
axis_name = axis_names[0]
if axis_name not in axis_names:
raise ValueError('%s not in %s' % (axis_name, axis_names))
axis = axis_names.index(axis_name)
unpack_ops = array_ops.unstack(labeled_tensor.tensor, axis=axis, name=scope)
axes = [a for i, a in enumerate(labeled_tensor.axes.values()) if i != axis]
return [core.LabeledTensor(t, axes) for t in unpack_ops]
@tc.returns(core.LabeledTensor)
@tc.accepts(core.LabeledTensorLike,
tc.Collection(string_types),
tc.Collection(tc.Union(string_types, core.AxisLike)),
tc.Optional(string_types))
def reshape(labeled_tensor, existing_axes, new_axes, name=None):
"""Reshape specific axes of a LabeledTensor.
Non-indicated axes remain in their original locations.
Args:
labeled_tensor: The input tensor.
existing_axes: List of axis names found on the input tensor. These must
appear sequentially in the list of axis names on the input. In other
words, they must be a valid slice of `list(labeled_tensor.axes.keys())`.
new_axes: List of strings, tuples of (axis_name, axis_value) or Axis objects
providing new axes with which to replace `existing_axes` in the reshaped
result. At most one element of `new_axes` may be a string, indicating an
axis with unknown size.
name: Optional op name.
Returns:
The reshaped LabeledTensor.
Raises:
ValueError: If `existing_axes` are not all axes on the input, or if more
than one of `new_axes` has unknown size.
AxisOrderError: If `existing_axes` are not a slice of axis names on the
input.
"""
with ops.name_scope(name, 'lt_reshape', [labeled_tensor]) as scope:
labeled_tensor = core.convert_to_labeled_tensor(labeled_tensor)
original_axis_names = list(labeled_tensor.axes.keys())
existing_axes = list(existing_axes)
if not set(existing_axes) <= set(original_axis_names):
raise ValueError('existing_axes %r are not contained in the set of axis '
'names %r on the input labeled tensor' %
(existing_axes, original_axis_names))
start = original_axis_names.index(existing_axes[0])
stop = original_axis_names.index(existing_axes[-1]) + 1
if existing_axes != original_axis_names[start:stop]:
# We could support existing_axes that aren't a slice by using transpose,
# but that could lead to unpredictable performance consequences because
# transposes are not free in TensorFlow. If we did transpose
# automatically, the user might never realize that their data is being
# produced with the wrong order. (The later will occur with some frequency
# because of how broadcasting automatically choose axis order.)
# So for now we've taken the strict approach.
raise core.AxisOrderError(
'existing_axes %r are not a slice of axis names %r on the input '
'labeled tensor. Use `transpose` or `impose_axis_order` to reorder '
'axes on the input explicitly.' %
(existing_axes, original_axis_names))
if sum(isinstance(axis, string_types) for axis in new_axes) > 1:
raise ValueError(
'at most one axis in new_axes can have unknown size. All other '
'axes must have an indicated integer size or labels: %r' % new_axes)
original_values = list(labeled_tensor.axes.values())
axis_size = lambda axis: -1 if axis.size is None else axis.size
shape = [axis_size(axis) for axis in original_values[:start]]
for axis_ref in new_axes:
if isinstance(axis_ref, string_types):
shape.append(-1)
else:
axis = core.as_axis(axis_ref)
shape.append(axis_size(axis))
shape.extend(axis_size(axis) for axis in original_values[stop:])
reshaped_tensor = array_ops.reshape(
labeled_tensor.tensor, shape, name=scope)
axes = original_values[:start] + list(new_axes) + original_values[stop:]
return core.LabeledTensor(reshaped_tensor, axes)
@tc.returns(core.LabeledTensor)
@tc.accepts(core.LabeledTensorLike, string_types, string_types,
tc.Optional(string_types))
def rename_axis(labeled_tensor, existing_name, new_name, name=None):
"""Rename an axis of LabeledTensor.
Args:
labeled_tensor: The input tensor.
existing_name: Name for an existing axis on the input.
new_name: Desired replacement name.
name: Optional op name.
Returns:
LabeledTensor with renamed axis.
Raises:
ValueError: If `existing_name` is not an axis on the input.
"""
with ops.name_scope(name, 'lt_rename_axis', [labeled_tensor]) as scope:
if existing_name not in labeled_tensor.axes:
raise ValueError('existing_name %r are not contained in the set of axis '
'names %r on the input labeled tensor' %
(existing_name, labeled_tensor.axes.keys()))
new_axis = core.Axis(new_name, labeled_tensor.axes[existing_name].value)
return reshape(labeled_tensor, [existing_name], [new_axis], name=scope)
@tc.returns(tc.List(core.LabeledTensor))
@tc.accepts(string_types, collections.Callable, int, bool,
tc.Collection(core.LabeledTensorLike), bool,
tc.Optional(string_types))
def _batch_helper(default_name,
batch_fn,
batch_size,
enqueue_many,
labeled_tensors,
allow_smaller_final_batch,
name=None):
with ops.name_scope(name, default_name, labeled_tensors) as scope:
labeled_tensors = [
core.convert_to_labeled_tensor(lt) for lt in labeled_tensors
]
batch_ops = batch_fn([t.tensor for t in labeled_tensors], scope)
# TODO(shoyer): Remove this when they sanitize the TF API.
if not isinstance(batch_ops, list):
assert isinstance(batch_ops, ops.Tensor)
batch_ops = [batch_ops]
if allow_smaller_final_batch:
batch_size = None
@tc.returns(core.Axes)
@tc.accepts(core.Axes)
def output_axes(axes):
if enqueue_many:
if 'batch' not in axes or list(axes.keys()).index('batch') != 0:
raise ValueError(
'When enqueue_many is True, input tensors must have an axis '
'called "batch" as their first dimension, '
'but axes were %s' % axes)
culled_axes = axes.remove('batch')
return core.Axes([('batch', batch_size)] + list(culled_axes.values()))
else:
return core.Axes([('batch', batch_size)] + list(axes.values()))
output_labeled_tensors = []
for i, tensor in enumerate(batch_ops):
axes = output_axes(labeled_tensors[i].axes)
output_labeled_tensors.append(core.LabeledTensor(tensor, axes))
return output_labeled_tensors
@tc.returns(tc.List(core.LabeledTensor))
@tc.accepts(
tc.Collection(core.LabeledTensorLike), int, int, int, bool, bool,
tc.Optional(string_types))
def batch(labeled_tensors,
batch_size,
num_threads=1,
capacity=32,
enqueue_many=False,
allow_smaller_final_batch=False,
name=None):
"""Rebatch a tensor.
See tf.batch.
Args:
labeled_tensors: The input tensors.
batch_size: The output batch size.
num_threads: See tf.batch.
capacity: See tf.batch.
enqueue_many: If true, the input tensors must contain a 'batch' axis as
their first axis.
If false, the input tensors must not contain a 'batch' axis.
See tf.batch.
allow_smaller_final_batch: See tf.batch.
name: Optional op name.
Returns:
The rebatched tensors.
If enqueue_many is false, the output tensors will have a new 'batch' axis
as their first axis.
Raises:
ValueError: If enqueue_many is True and the first axis of the tensors
isn't "batch".
"""
def fn(tensors, scope):
return input.batch(
tensors,
batch_size=batch_size,
num_threads=num_threads,
capacity=capacity,
enqueue_many=enqueue_many,
allow_smaller_final_batch=allow_smaller_final_batch,
name=scope)
return _batch_helper('lt_batch', fn, batch_size, enqueue_many,
labeled_tensors, allow_smaller_final_batch, name)
@tc.returns(tc.List(core.LabeledTensor))
@tc.accepts(
tc.Collection(core.LabeledTensorLike), int, int, int, bool, int,
tc.Optional(int), bool, tc.Optional(string_types))
def shuffle_batch(labeled_tensors,
batch_size,
num_threads=1,
capacity=32,
enqueue_many=False,
min_after_dequeue=0,
seed=None,
allow_smaller_final_batch=False,
name=None):
"""Rebatch a tensor, with shuffling.
See tf.batch.
Args:
labeled_tensors: The input tensors.
batch_size: The output batch size.
num_threads: See tf.batch.
capacity: See tf.batch.
enqueue_many: If true, the input tensors must contain a 'batch' axis as
their first axis.
If false, the input tensors must not contain a 'batch' axis.
See tf.batch.
min_after_dequeue: Minimum number of elements in the queue after a dequeue,
used to ensure mixing.
seed: Optional random seed.
allow_smaller_final_batch: See tf.batch.
name: Optional op name.
Returns:
The rebatched tensors.
If enqueue_many is false, the output tensors will have a new 'batch' axis
as their first axis.
Raises:
ValueError: If enqueue_many is True and the first axis of the tensors
isn't "batch".
"""
def fn(tensors, scope):
return input.shuffle_batch(
tensors,
batch_size=batch_size,
num_threads=num_threads,
capacity=capacity,
enqueue_many=enqueue_many,
min_after_dequeue=min_after_dequeue,
seed=seed,
allow_smaller_final_batch=allow_smaller_final_batch,
name=scope)
return _batch_helper('lt_shuffle_batch', fn, batch_size, enqueue_many,
labeled_tensors, allow_smaller_final_batch, name)
@tc.returns(core.LabeledTensor)
@tc.accepts(core.LabeledTensorLike,
tc.Mapping(string_types, int),
tc.Optional(int), tc.Optional(string_types))
def random_crop(labeled_tensor, shape_map, seed=None, name=None):
"""Randomly crops a tensor to a given size.
See tf.random_crop.
Args:
labeled_tensor: The input tensor.
shape_map: A dictionary mapping axis names to the size of the random crop
for that dimension.
seed: An optional random seed.
name: An optional op name.
Returns:
A tensor of the same rank as `labeled_tensor`, cropped randomly in the
selected dimensions.
Raises:
ValueError: If the shape map contains an axis name not in the input tensor.
"""
with ops.name_scope(name, 'lt_random_crop', [labeled_tensor]) as scope:
labeled_tensor = core.convert_to_labeled_tensor(labeled_tensor)
for axis_name in shape_map:
if axis_name not in labeled_tensor.axes:
raise ValueError('Selection axis %s not in axes %s' %
(axis_name, labeled_tensor.axes))
shape = []
axes = []
for axis in labeled_tensor.axes.values():
if axis.name in shape_map:
size = shape_map[axis.name]
shape.append(size)
# We lose labels for the axes we crop, leaving just the size.
axes.append((axis.name, size))
else:
shape.append(len(axis))
axes.append(axis)
crop_op = random_ops.random_crop(
labeled_tensor.tensor, shape, seed=seed, name=scope)
return core.LabeledTensor(crop_op, axes)
# TODO(shoyer): Allow the user to select the axis over which to map.
@tc.returns(core.LabeledTensor)
@tc.accepts(collections.Callable, core.LabeledTensorLike,
tc.Optional(string_types))
def map_fn(fn, labeled_tensor, name=None):
"""Map on the list of tensors unpacked from labeled_tensor.
See tf.map_fn.
Args:
fn: The function to apply to each unpacked LabeledTensor.
It should have type LabeledTensor -> LabeledTensor.
labeled_tensor: The input tensor.
name: Optional op name.
Returns:
A tensor that packs the results of applying fn to the list of tensors
unpacked from labeled_tensor.
"""
with ops.name_scope(name, 'lt_map_fn', [labeled_tensor]) as scope:
labeled_tensor = core.convert_to_labeled_tensor(labeled_tensor)
unpack_lts = unpack(labeled_tensor)
# TODO(ericmc): Fix this upstream.
if labeled_tensor.dtype == dtypes.string:
# We must construct the full graph here, because functional_ops.map_fn
# doesn't work for string-valued tensors.
# Constructing the full graph may be slow.
map_lts = [fn(t) for t in unpack_lts]
return pack(map_lts, list(labeled_tensor.axes.values())[0], name=scope)
else:
# Figure out what the axis labels should be, but use tf.map_fn to
# construct the graph because it's efficient.
# It may be slow to construct the full graph, so we infer the labels from
# the first element.
# TODO(ericmc): This builds a subgraph which then gets thrown away.
# Find a more elegant solution.
first_map_lt = fn(unpack_lts[0])
final_axes = list(labeled_tensor.axes.values())[:1] + list(
first_map_lt.axes.values())
@tc.returns(ops.Tensor)
@tc.accepts(ops.Tensor)
def tf_fn(tensor):
original_axes = list(labeled_tensor.axes.values())[1:]
tensor_lt = core.LabeledTensor(tensor, original_axes)
return fn(tensor_lt).tensor
map_op = functional_ops.map_fn(tf_fn, labeled_tensor.tensor)
map_lt = core.LabeledTensor(map_op, final_axes)
return core.identity(map_lt, name=scope)
@tc.returns(core.LabeledTensor)
@tc.accepts(collections.Callable, core.LabeledTensorLike,
core.LabeledTensorLike, tc.Optional(string_types))
def foldl(fn, labeled_tensor, initial_value, name=None):
"""Left fold on the list of tensors unpacked from labeled_tensor.
See tf.foldl.
Args:
fn: The function to apply to each unpacked LabeledTensor.
It should have type (LabeledTensor, LabeledTensor) -> LabeledTensor.
Its arguments are (accumulated_value, next_value).
labeled_tensor: The input tensor.
initial_value: The initial value of the accumulator.
name: Optional op name.
Returns:
The accumulated value.
"""
with ops.name_scope(name, 'lt_foldl',
[labeled_tensor, initial_value]) as scope:
labeled_tensor = core.convert_to_labeled_tensor(labeled_tensor)
initial_value = core.convert_to_labeled_tensor(initial_value)
@tc.returns(ops.Tensor)
@tc.accepts(ops.Tensor, ops.Tensor)
def tf_fn(accumulator, next_element):
accumulator_lt = core.LabeledTensor(accumulator, initial_value.axes)
next_element_lt = core.LabeledTensor(
next_element, list(labeled_tensor.axes.values())[1:])
return fn(accumulator_lt, next_element_lt).tensor
foldl_op = functional_ops.foldl(
tf_fn, labeled_tensor.tensor, initializer=initial_value.tensor)
foldl_lt = core.LabeledTensor(foldl_op, initial_value.axes)
return core.identity(foldl_lt, name=scope)
@tc.returns(core.LabeledTensor)
@tc.accepts(core.LabeledTensorLike,
tc.Optional(tc.Collection(string_types)), tc.Optional(string_types))
def squeeze(labeled_tensor, axis_names=None, name=None):
"""Remove size-1 dimensions.
See tf.squeeze.
Args:
labeled_tensor: The input tensor.
axis_names: The names of the dimensions to remove, or None to remove
all size-1 dimensions.
name: Optional op name.
Returns:
A tensor with the specified dimensions removed.
Raises:
ValueError: If the named axes are not in the tensor, or if they are
not size-1.
"""
with ops.name_scope(name, 'lt_squeeze', [labeled_tensor]) as scope:
labeled_tensor = core.convert_to_labeled_tensor(labeled_tensor)
if axis_names is None:
axis_names = [a.name for a in labeled_tensor.axes.values() if len(a) == 1]
for axis_name in axis_names:
if axis_name not in labeled_tensor.axes:
raise ValueError('axis %s is not in tensor axes %s' %
(axis_name, labeled_tensor.axes))
elif len(labeled_tensor.axes[axis_name]) != 1:
raise ValueError(
'cannot squeeze axis with size greater than 1: (%s, %s)' %
(axis_name, labeled_tensor.axes[axis_name]))
squeeze_dimensions = []
axes = []
for i, axis in enumerate(labeled_tensor.axes.values()):
if axis.name in axis_names:
squeeze_dimensions.append(i)
else:
axes.append(axis)
if squeeze_dimensions:
squeeze_op = array_ops.squeeze(
labeled_tensor.tensor, squeeze_dimensions, name=scope)
else:
squeeze_op = array_ops.identity(labeled_tensor.tensor, name=scope)
return core.LabeledTensor(squeeze_op, axes)
# pylint: disable=invalid-name
ReduceAxis = tc.Union(string_types,
tc.Tuple(string_types, collections.Hashable))
ReduceAxes = tc.Optional(tc.Union(ReduceAxis, tc.Collection(ReduceAxis)))
# pylint: enable=invalid-name
@tc.returns(core.LabeledTensor)
@tc.accepts(core.LabeledTensorLike, core.LabeledTensorLike,
tc.Optional(string_types))
def matmul(a, b, name=None):
"""Matrix multiply two tensors with rank 1 or 2.
If both tensors have rank 2, a matrix-matrix product is performed.
If one tensor has rank 1 and the other has rank 2, then a matrix-vector
product is performed.
If both tensors have rank 1, then a vector dot-product is performed.
(This behavior matches that of `numpy.dot`.)
Both tensors must share exactly one dimension in common, which is the
dimension the operation is summed along. The inputs will be automatically
transposed if necessary as part of the matmul op.
We intend to eventually support `matmul` on higher rank input, and also
eventually support summing over any number shared dimensions (via an `axis`
argument), but neither of these features has been implemented yet.
Args:
a: First LabeledTensor.
b: Second LabeledTensor.
name: Optional op name.
Returns:
LabeledTensor with the result of matrix multiplication. Axes are ordered by
the current axis_order_scope, if set, or in or order of appearance on the
inputs.
Raises:
NotImplementedError: If inputs have rank >2 or share multiple axes.
ValueError: If the inputs have rank 0 or do not share any axes.
"""
with ops.name_scope(name, 'lt_matmul', [a, b]) as scope:
a = core.convert_to_labeled_tensor(a)
b = core.convert_to_labeled_tensor(b)
if len(a.axes) > 2 or len(b.axes) > 2:
# We could pass batched inputs to tf.matmul to make this work, but we
# would also need to use tf.tile and/or tf.transpose. These are more
# expensive than doing reshapes, so it's not clear if it's a good idea to
# do this automatically.
raise NotImplementedError(
'matmul currently requires inputs with rank 2 or less, but '
'inputs have ranks %r and %r' % (len(a.axes), len(b.axes)))
if not a.axes or not b.axes:
raise ValueError(
'matmul currently requires inputs with at least rank 1, but '
'inputs have ranks %r and %r' % (len(a.axes), len(b.axes)))
shared_axes = set(a.axes) & set(b.axes)
if len(shared_axes) > 1:
raise NotImplementedError(
'matmul does not yet support summing over multiple shared axes: %r. '
'Use transpose and reshape to create a single shared axis to sum '
'over.' % shared_axes)
if not shared_axes:
raise ValueError('there must have exactly one axis in common between '
'input to matmul: %r, %r' %
(a.axes.keys(), b.axes.keys()))
shared_axis, = shared_axes
if a.axes[shared_axis] != b.axes[shared_axis]:
raise ValueError('axis %r does not match on input arguments: %r vs %r' %
(shared_axis, a.axes[shared_axis].value,
b.axes[shared_axis].value))
result_axes = []
for axes in [a.axes, b.axes]:
for axis in axes.values():
if axis.name != shared_axis:
result_axes.append(axis)
axis_scope_order = core.get_axis_order()
if axis_scope_order is not None:
result_axis_names = [axis.name for axis in result_axes]
new_axis_names = [
name for name in axis_scope_order if name in result_axis_names
]
if new_axis_names != result_axis_names:
# switch a and b
b, a = a, b
# result_axes is a list of length 1 or 2
result_axes = result_axes[::-1]
squeeze_dims = []
if len(a.axes) == 1:
a_tensor = array_ops.reshape(a.tensor, (1, -1))
squeeze_dims.append(0)
transpose_a = False
else:
a_tensor = a.tensor
transpose_a = list(a.axes.keys()).index(shared_axis) == 0
if len(b.axes) == 1:
b_tensor = array_ops.reshape(b.tensor, (-1, 1))
squeeze_dims.append(1)
transpose_b = False
else:
b_tensor = b.tensor
transpose_b = list(b.axes.keys()).index(shared_axis) == 1
result_op = math_ops.matmul(
a_tensor, b_tensor, transpose_a=transpose_a, transpose_b=transpose_b)
if squeeze_dims:
result_op = array_ops.squeeze(result_op, squeeze_dims)
result_op = array_ops.identity(result_op, name=scope)
return core.LabeledTensor(result_op, result_axes)
@tc.returns(types.FunctionType)
@tc.accepts(string_types, collections.Callable)
def define_reduce_op(op_name, reduce_fn):
"""Define a reduction op for labeled tensors.
Args:
op_name: string name of the TensorFlow op.
reduce_fn: function to call to evaluate the op on a tf.Tensor.
Returns:
Function defining the given reduction op that acts on a LabeledTensor.
"""
default_name = 'lt_%s' % op_name
@tc.returns(core.LabeledTensor)
@tc.accepts(core.LabeledTensorLike, ReduceAxes, tc.Optional(string_types))
def op(labeled_tensor, axes=None, name=None):
"""Computes the given reduction across the given axes of a LabeledTensor.
See `tf.{op_name}` for full details.
Args:
labeled_tensor: The input tensor.
axes: A set of axes or None.
If None, all axes will be reduced.
Axes must all be strings, in which case those dimensions will be
removed, or pairs of (name, None) or (name, label), in which case those
dimensions will be kept.
name: Optional op name.
Returns:
The reduced LabeledTensor.
Raises:
ValueError: if any of the axes to reduce over are not found on
`labeled_tensor`.
"""
with ops.name_scope(name, default_name, [labeled_tensor]) as scope:
labeled_tensor = core.convert_to_labeled_tensor(labeled_tensor)
if axes is None:
axes = labeled_tensor.axes.keys()
if isinstance(axes, (string_types, tuple)):
axes = [axes]
reduction_axes = {}
axes_to_squeeze = []
for a in axes:
if isinstance(a, string_types):
# We squeeze out this axis.
reduction_axes[a] = a
axes_to_squeeze.append(a)
else:
# We keep this axis, with the user-provided labels.
(axis_name, label) = a
if label is not None:
# The input was a single label, so make it a list so it can be
# turned into an Axis.
label = [label]
reduction_axes[axis_name] = (axis_name, label)
for axis_name in reduction_axes:
if axis_name not in labeled_tensor.axes:
raise ValueError('Axis %s not in axes %s' %
(axis_name, labeled_tensor.axes))
intermediate_axes = []
reduction_dimensions = []
for i, axis in enumerate(labeled_tensor.axes.values()):
if axis.name in reduction_axes:
intermediate_axes.append(reduction_axes[axis.name])
reduction_dimensions.append(i)
else:
intermediate_axes.append(axis)
reduce_op = reduce_fn(
labeled_tensor.tensor, reduction_dimensions, keep_dims=True)
reduce_lt = core.LabeledTensor(reduce_op, intermediate_axes)
return squeeze(reduce_lt, axes_to_squeeze, name=scope)
op.__doc__ = op.__doc__.format(op_name=op_name)
op.__name__ = op_name
return op
reduce_all = define_reduce_op('reduce_all', math_ops.reduce_all)
reduce_any = define_reduce_op('reduce_any', math_ops.reduce_any)
reduce_logsumexp = define_reduce_op('reduce_logsumexp',
math_ops.reduce_logsumexp)
reduce_max = define_reduce_op('reduce_max', math_ops.reduce_max)
reduce_mean = define_reduce_op('reduce_mean', math_ops.reduce_mean)
reduce_min = define_reduce_op('reduce_min', math_ops.reduce_min)
reduce_prod = define_reduce_op('reduce_prod', math_ops.reduce_prod)
reduce_sum = define_reduce_op('reduce_sum', math_ops.reduce_sum)
@tc.returns(core.LabeledTensor)
@tc.accepts(core.LabeledTensorLike,
tc.Mapping(str, tc.Union(int, ops.Tensor)),
tc.Optional(string_types))
def tile(labeled_tensor, multiples, name=None):
"""Constructs a tensor by tiling a given tensor.
Only axes without tick-labels can be tiled. (Otherwise, axis labels on tiled
tensors would no longer be unique.)
See lt.tile.
Args:
labeled_tensor: The input tensor.
multiples: A mapping where the keys are axis names and the values are the
integer number of times to tile along that axis. Only axes with a multiple
different than 1 need be included.
name: Optional op name.
Returns:
A tensor with the indicated axes tiled.
Raises:
ValueError: If the tiled axes are not axes in the input tensor, or if any
axes in multiples have tick labels.
"""
with ops.name_scope(name, 'lt_tile', [labeled_tensor]) as scope:
labeled_tensor = core.convert_to_labeled_tensor(labeled_tensor)
if not set(multiples.keys()) <= set(labeled_tensor.axes.keys()):
raise ValueError('tile axes %r are not contained in the set of axis '
'names %r on the input labeled tensor' %
(multiples.keys(), labeled_tensor.axes))
labeled_axes = [
name for name in multiples
if labeled_tensor.axes[name].labels is not None
]
if labeled_axes:
raise ValueError('cannot tile axes with tick labels: %r' % labeled_axes)
multiples_list = [multiples.get(name, 1) for name in labeled_tensor.axes]
tile_op = array_ops.tile(labeled_tensor.tensor, multiples_list, name=scope)
new_axes = [
axis.name if axis.labels is None else axis
for axis in labeled_tensor.axes.values()
]
return core.LabeledTensor(tile_op, new_axes)
@tc.returns(core.LabeledTensor)
@tc.accepts(core.LabeledTensorLike,
tc.Mapping(str, tc.Tuple(core.AxisValue, core.AxisValue)),
string_types, tc.Optional(string_types))
def pad(labeled_tensor, paddings, mode='CONSTANT', name=None):
"""Pads a tensor.
See tf.pad.
Args:
labeled_tensor: The input tensor.
paddings: A mapping where the keys are axis names and the values are
tuples where the first element is the padding to insert at the beginning
of the axis and the second is the padding to insert at the end of the
axis.
mode: One of "CONSTANT", "REFLECT", or "SYMMETRIC".
name: Optional op name.
Returns:
A tensor with the indicated axes padded, optionally with those axes extended
with the provided labels.
Raises:
ValueError: If the padded axes are not axes in the input tensor.
"""
with ops.name_scope(name, 'lt_pad', [labeled_tensor]) as scope:
labeled_tensor = core.convert_to_labeled_tensor(labeled_tensor)
if not set(paddings.keys()) <= set(labeled_tensor.axes.keys()):
raise ValueError('pad axes %r are not contained in the set of axis '
'names %r on the input labeled tensor' %
(paddings.keys(), labeled_tensor.axes))
new_axes = []
padding_pairs = []
for name, axis in labeled_tensor.axes.items():
if name in paddings:
padding_before, padding_after = paddings[name]
axis_before = core.Axis(name, padding_before)
axis_after = core.Axis(name, padding_after)
new_axes.append(core.concat_axes([axis_before, axis, axis_after]))
padding_pairs.append((len(axis_before), len(axis_after)))
else:
new_axes.append(axis)
padding_pairs.append((0, 0))
pad_op = array_ops.pad(labeled_tensor.tensor,
padding_pairs,
mode,
name=scope)
return core.LabeledTensor(pad_op, new_axes)
@tc.returns(core.LabeledTensor)
@tc.accepts(
tc.Union(np.ndarray, list, tuple, core.Scalar),
tc.Optional(dtypes.DType),
tc.Optional(
tc.Union(core.Axes, tc.Collection(
tc.Union(string_types, core.AxisLike)))), tc.Optional(string_types))
def constant(value, dtype=None, axes=None, name=None):
"""Creates a constant tensor.
If `axes` includes any strings, shape is inferred from `value`. Otherwise,
the sizes of the given `axes` are used to set `shape` for `tf.constant`.
See tf.constant for more details.
Args:
value: The input tensor.
dtype: The type of the returned tensor.
axes: Optional Axes, list of strings or list of objects coercible to Axis
objects. By default, axes are assumed to be an empty list (i.e., `value`
is treated as a scalar).
name: Optional op name.
Returns:
The tensor with elements set to zero.
"""
with ops.name_scope(name, 'lt_constant', [value]) as scope:
if axes is None:
axes = []
if isinstance(axes, core.Axes):
axes = axes.values()
if any(isinstance(ax, string_types) for ax in axes):
# need to infer shape
shape = None
else:
# axes already indicate shape
axes = [core.as_axis(a) for a in axes]
shape = [a.size for a in axes]
op = array_ops.constant(value, dtype=dtype, shape=shape, name=scope)
return core.LabeledTensor(op, axes)
@tc.returns(core.LabeledTensor)
@tc.accepts(core.LabeledTensorLike,
tc.Optional(dtypes.DType), tc.Optional(string_types))
def zeros_like(labeled_tensor, dtype=None, name=None):
"""Creates an identical tensor with all elements set to zero.
Args:
labeled_tensor: The input tensor.
dtype: The type of the returned tensor.
name: Optional op name.
Returns:
The tensor with elements set to zero.
"""
with ops.name_scope(name, 'lt_zeros_like', [labeled_tensor]) as scope:
labeled_tensor = core.convert_to_labeled_tensor(labeled_tensor)
op = array_ops.zeros_like(labeled_tensor.tensor, dtype=dtype, name=scope)
return core.LabeledTensor(op, labeled_tensor.axes)
@tc.returns(core.LabeledTensor)
@tc.accepts(core.LabeledTensorLike,
tc.Optional(dtypes.DType), tc.Optional(string_types))
def ones_like(labeled_tensor, dtype=None, name=None):
"""Creates an identical tensor with all elements set to one.
Args:
labeled_tensor: The input tensor.
dtype: The type of the returned tensor.
name: Optional op name.
Returns:
The tensor with elements set to one.
"""
with ops.name_scope(name, 'lt_ones_like', [labeled_tensor]) as scope:
labeled_tensor = core.convert_to_labeled_tensor(labeled_tensor)
op = array_ops.ones_like(labeled_tensor.tensor, dtype=dtype, name=scope)
return core.LabeledTensor(op, labeled_tensor.axes)
@tc.returns(core.LabeledTensor)
@tc.accepts(core.LabeledTensorLike,
tc.Optional(dtypes.DType), tc.Optional(string_types))
def cast(labeled_tensor, dtype=None, name=None):
"""Casts a labeled tensor to a new type.
Args:
labeled_tensor: The input tensor.
dtype: The type of the returned tensor.
name: Optional op name.
Returns:
A labeled tensor with the new dtype.
"""
with ops.name_scope(name, 'lt_cast', [labeled_tensor]) as scope:
labeled_tensor = core.convert_to_labeled_tensor(labeled_tensor)
op = math_ops.cast(labeled_tensor.tensor, dtype=dtype, name=scope)
return core.LabeledTensor(op, labeled_tensor.axes)
@tc.returns(core.LabeledTensor)
@tc.accepts(core.LabeledTensorLike, string_types, tc.Optional(string_types))
def verify_tensor_all_finite(labeled_tensor, message, name=None):
"""Asserts a tensor doesn't contain NaNs or Infs.
See tf.verify_tensor_all_finite.
Args:
labeled_tensor: The input tensor.
message: Message to log on failure.
name: Optional op name.
Returns:
The input tensor.
"""
with ops.name_scope(name, 'lt_verify_tensor_all_finite',
[labeled_tensor]) as scope:
labeled_tensor = core.convert_to_labeled_tensor(labeled_tensor)
op = numerics.verify_tensor_all_finite(
labeled_tensor.tensor, msg=message, name=scope)
return core.LabeledTensor(op, labeled_tensor.axes)
@tc.returns(core.LabeledTensor)
@tc.accepts(core.LabeledTensorLike, core.LabeledTensorLike,
tc.Optional(string_types))
def boolean_mask(labeled_tensor, mask, name=None):
"""Apply a boolean mask to a labeled tensor.
Unlike `tf.boolean_mask`, this currently only works on 1-dimensional masks.
The mask is applied to the first axis of `labeled_tensor`. Labels on the first
axis are removed, because True indices in `mask` may not be known dynamically.
Args:
labeled_tensor: The input tensor.
mask: The type of the returned tensor.
name: Optional op name.
Returns:
The masked labeled tensor.
Raises:
ValueError: if the first axis of the mask
"""
with ops.name_scope(name, 'lt_boolean_mask', [labeled_tensor, mask]) as scope:
labeled_tensor = core.convert_to_labeled_tensor(labeled_tensor)
mask = core.convert_to_labeled_tensor(mask)
if len(mask.axes) > 1:
raise NotImplementedError(
"LabeledTensor's boolean_mask currently only supports 1D masks")
mask_axis = list(mask.axes.values())[0]
lt_axis = list(labeled_tensor.axes.values())[0]
if mask_axis != lt_axis:
raise ValueError('the first axis of the labeled tensor and the mask '
'are not equal:\n%r\n%r' % (lt_axis, mask_axis))
op = array_ops.boolean_mask(labeled_tensor.tensor, mask.tensor, name=scope)
# TODO(shoyer): attempt to infer labels for the masked values, by calling
# tf.contrib.util.constant_value on the mask?
axes = [lt_axis.name] + list(labeled_tensor.axes.values())[1:]
return core.LabeledTensor(op, axes)
@tc.returns(core.LabeledTensor)
@tc.accepts(core.LabeledTensorLike, core.LabeledTensorLike,
core.LabeledTensorLike, tc.Optional(string_types))
def where(condition, x, y, name=None):
"""Return elements from x or y depending on condition.
See `tf.where` for more details. This function currently only implements the
three argument version of where.
Args:
condition: LabeledTensor of type `bool`.
x: LabeledTensor for values where condition is true.
y: LabeledTensor for values where condition is false.
name: Optional op name.
Returns:
The labeled tensor with values according to condition.
Raises:
ValueError: if `x` and `y` have different axes, or if the axes of `x` do not
start with the axes of `condition`.
"""
with ops.name_scope(name, 'lt_where', [condition, x, y]) as scope:
condition = core.convert_to_labeled_tensor(condition)
x = core.convert_to_labeled_tensor(x)
y = core.convert_to_labeled_tensor(y)
if not condition.axes == x.axes == y.axes:
raise ValueError('all inputs to `where` must have equal axes')
op = array_ops.where(condition.tensor, x.tensor, y.tensor, name=scope)
return core.LabeledTensor(op, x.axes)
| apache-2.0 |
detrout/debian-statsmodels | statsmodels/sandbox/survival2.py | 35 | 17924 | #Kaplan-Meier Estimator
import numpy as np
import numpy.linalg as la
import matplotlib.pyplot as plt
from scipy import stats
from statsmodels.iolib.table import SimpleTable
class KaplanMeier(object):
"""
KaplanMeier(...)
KaplanMeier(data, endog, exog=None, censoring=None)
Create an object of class KaplanMeier for estimating
Kaplan-Meier survival curves.
Parameters
----------
data: array_like
An array, with observations in each row, and
variables in the columns
endog: index (starting at zero) of the column
containing the endogenous variable (time)
exog: index of the column containing the exogenous
variable (must be catagorical). If exog = None, this
is equivalent to a single survival curve
censoring: index of the column containing an indicator
of whether an observation is an event, or a censored
observation, with 0 for censored, and 1 for an event
Attributes
-----------
censorings: List of censorings associated with each unique
time, at each value of exog
events: List of the number of events at each unique time
for each value of exog
results: List of arrays containing estimates of the value
value of the survival function and its standard error
at each unique time, for each value of exog
ts: List of unique times for each value of exog
Methods
-------
fit: Calcuate the Kaplan-Meier estimates of the survival
function and its standard error at each time, for each
value of exog
plot: Plot the survival curves using matplotlib.plyplot
summary: Display the results of fit in a table. Gives results
for all (including censored) times
test_diff: Test for difference between survival curves
Examples
--------
>>> import statsmodels.api as sm
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> from statsmodels.sandbox.survival2 import KaplanMeier
>>> dta = sm.datasets.strikes.load()
>>> dta = dta.values()[-1]
>>> dta[range(5),:]
array([[ 7.00000000e+00, 1.13800000e-02],
[ 9.00000000e+00, 1.13800000e-02],
[ 1.30000000e+01, 1.13800000e-02],
[ 1.40000000e+01, 1.13800000e-02],
[ 2.60000000e+01, 1.13800000e-02]])
>>> km = KaplanMeier(dta,0)
>>> km.fit()
>>> km.plot()
Doing
>>> km.summary()
will display a table of the estimated survival and standard errors
for each time. The first few lines are
Kaplan-Meier Curve
=====================================
Time Survival Std. Err
-------------------------------------
1.0 0.983870967742 0.0159984306572
2.0 0.91935483871 0.0345807888235
3.0 0.854838709677 0.0447374942184
4.0 0.838709677419 0.0467104592871
5.0 0.822580645161 0.0485169952543
Doing
>>> plt.show()
will plot the survival curve
Mutliple survival curves:
>>> km2 = KaplanMeier(dta,0,exog=1)
>>> km2.fit()
km2 will estimate a survival curve for each value of industrial
production, the column of dta with index one (1).
With censoring:
>>> censoring = np.ones_like(dta[:,0])
>>> censoring[dta[:,0] > 80] = 0
>>> dta = np.c_[dta,censoring]
>>> dta[range(5),:]
array([[ 7.00000000e+00, 1.13800000e-02, 1.00000000e+00],
[ 9.00000000e+00, 1.13800000e-02, 1.00000000e+00],
[ 1.30000000e+01, 1.13800000e-02, 1.00000000e+00],
[ 1.40000000e+01, 1.13800000e-02, 1.00000000e+00],
[ 2.60000000e+01, 1.13800000e-02, 1.00000000e+00]])
>>> km3 = KaplanMeier(dta,0,exog=1,censoring=2)
>>> km3.fit()
Test for difference of survival curves
>>> log_rank = km3.test_diff([0.0645,-0.03957])
The zeroth element of log_rank is the chi-square test statistic
for the difference between the survival curves for exog = 0.0645
and exog = -0.03957, the index one element is the degrees of freedom for
the test, and the index two element is the p-value for the test
Groups with nan names
>>> groups = np.ones_like(dta[:,1])
>>> groups = groups.astype('S4')
>>> groups[dta[:,1] > 0] = 'high'
>>> groups[dta[:,1] <= 0] = 'low'
>>> dta = dta.astype('S4')
>>> dta[:,1] = groups
>>> dta[range(5),:]
array([['7.0', 'high', '1.0'],
['9.0', 'high', '1.0'],
['13.0', 'high', '1.0'],
['14.0', 'high', '1.0'],
['26.0', 'high', '1.0']],
dtype='|S4')
>>> km4 = KaplanMeier(dta,0,exog=1,censoring=2)
>>> km4.fit()
"""
def __init__(self, data, endog, exog=None, censoring=None):
self.exog = exog
self.censoring = censoring
cols = [endog]
self.endog = 0
if exog != None:
cols.append(exog)
self.exog = 1
if censoring != None:
cols.append(censoring)
if exog != None:
self.censoring = 2
else:
self.censoring = 1
data = data[:,cols]
if data.dtype == float or data.dtype == int:
self.data = data[~np.isnan(data).any(1)]
else:
t = (data[:,self.endog]).astype(float)
if exog != None:
evec = data[:,self.exog]
evec = evec[~np.isnan(t)]
if censoring != None:
cvec = (data[:,self.censoring]).astype(float)
cvec = cvec[~np.isnan(t)]
t = t[~np.isnan(t)]
if censoring != None:
t = t[~np.isnan(cvec)]
if exog != None:
evec = evec[~np.isnan(cvec)]
cvec = cvec[~np.isnan(cvec)]
cols = [t]
if exog != None:
cols.append(evec)
if censoring != None:
cols.append(cvec)
data = (np.array(cols)).transpose()
self.data = data
def fit(self):
"""
Calculate the Kaplan-Meier estimator of the survival function
"""
self.results = []
self.ts = []
self.censorings = []
self.event = []
if self.exog == None:
self.fitting_proc(self.data)
else:
groups = np.unique(self.data[:,self.exog])
self.groups = groups
for g in groups:
group = self.data[self.data[:,self.exog] == g]
self.fitting_proc(group)
def plot(self):
"""
Plot the estimated survival curves. After using this method
do
plt.show()
to display the plot
"""
plt.figure()
if self.exog == None:
self.plotting_proc(0)
else:
for g in range(len(self.groups)):
self.plotting_proc(g)
plt.ylim(ymax=1.05)
plt.ylabel('Survival')
plt.xlabel('Time')
def summary(self):
"""
Print a set of tables containing the estimates of the survival
function, and its standard errors
"""
if self.exog == None:
self.summary_proc(0)
else:
for g in range(len(self.groups)):
self.summary_proc(g)
def fitting_proc(self, group):
"""
For internal use
"""
t = ((group[:,self.endog]).astype(float)).astype(int)
if self.censoring == None:
events = np.bincount(t)
t = np.unique(t)
events = events[:,list(t)]
events = events.astype(float)
eventsSum = np.cumsum(events)
eventsSum = np.r_[0,eventsSum]
n = len(group) - eventsSum[:-1]
else:
censoring = ((group[:,self.censoring]).astype(float)).astype(int)
reverseCensoring = -1*(censoring - 1)
events = np.bincount(t,censoring)
censored = np.bincount(t,reverseCensoring)
t = np.unique(t)
censored = censored[:,list(t)]
censored = censored.astype(float)
censoredSum = np.cumsum(censored)
censoredSum = np.r_[0,censoredSum]
events = events[:,list(t)]
events = events.astype(float)
eventsSum = np.cumsum(events)
eventsSum = np.r_[0,eventsSum]
n = len(group) - eventsSum[:-1] - censoredSum[:-1]
(self.censorings).append(censored)
survival = np.cumprod(1-events/n)
var = ((survival*survival) *
np.cumsum(events/(n*(n-events))))
se = np.sqrt(var)
(self.results).append(np.array([survival,se]))
(self.ts).append(t)
(self.event).append(events)
def plotting_proc(self, g):
"""
For internal use
"""
survival = self.results[g][0]
t = self.ts[g]
e = (self.event)[g]
if self.censoring != None:
c = self.censorings[g]
csurvival = survival[c != 0]
ct = t[c != 0]
if len(ct) != 0:
plt.vlines(ct,csurvival+0.02,csurvival-0.02)
x = np.repeat(t[e != 0], 2)
y = np.repeat(survival[e != 0], 2)
if self.ts[g][-1] in t[e != 0]:
x = np.r_[0,x]
y = np.r_[1,1,y[:-1]]
else:
x = np.r_[0,x,self.ts[g][-1]]
y = np.r_[1,1,y]
plt.plot(x,y)
def summary_proc(self, g):
"""
For internal use
"""
if self.exog != None:
myTitle = ('exog = ' + str(self.groups[g]) + '\n')
else:
myTitle = "Kaplan-Meier Curve"
table = np.transpose(self.results[g])
table = np.c_[np.transpose(self.ts[g]),table]
table = SimpleTable(table, headers=['Time','Survival','Std. Err'],
title = myTitle)
print(table)
def test_diff(self, groups, rho=None, weight=None):
"""
test_diff(groups, rho=0)
Test for difference between survival curves
Parameters
----------
groups: A list of the values for exog to test for difference.
tests the null hypothesis that the survival curves for all
values of exog in groups are equal
rho: compute the test statistic with weight S(t)^rho, where
S(t) is the pooled estimate for the Kaplan-Meier survival function.
If rho = 0, this is the logrank test, if rho = 0, this is the
Peto and Peto modification to the Gehan-Wilcoxon test.
weight: User specified function that accepts as its sole arguement
an array of times, and returns an array of weights for each time
to be used in the test
Returns
-------
An array whose zeroth element is the chi-square test statistic for
the global null hypothesis, that all survival curves are equal,
the index one element is degrees of freedom for the test, and the
index two element is the p-value for the test.
Examples
--------
>>> import statsmodels.api as sm
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> from statsmodels.sandbox.survival2 import KaplanMeier
>>> dta = sm.datasets.strikes.load()
>>> dta = dta.values()[-1]
>>> censoring = np.ones_like(dta[:,0])
>>> censoring[dta[:,0] > 80] = 0
>>> dta = np.c_[dta,censoring]
>>> km = KaplanMeier(dta,0,exog=1,censoring=2)
>>> km.fit()
Test for difference of survival curves
>>> log_rank = km3.test_diff([0.0645,-0.03957])
The zeroth element of log_rank is the chi-square test statistic
for the difference between the survival curves using the log rank test
for exog = 0.0645 and exog = -0.03957, the index one element
is the degrees of freedom for the test, and the index two element
is the p-value for the test
>>> wilcoxon = km.test_diff([0.0645,-0.03957], rho=1)
wilcoxon is the equivalent information as log_rank, but for the
Peto and Peto modification to the Gehan-Wilcoxon test.
User specified weight functions
>>> log_rank = km3.test_diff([0.0645,-0.03957], weight=np.ones_like)
This is equivalent to the log rank test
More than two groups
>>> log_rank = km.test_diff([0.0645,-0.03957,0.01138])
The test can be performed with arbitrarily many groups, so long as
they are all in the column exog
"""
groups = np.asarray(groups)
if self.exog == None:
raise ValueError("Need an exogenous variable for logrank test")
elif (np.in1d(groups,self.groups)).all():
data = self.data[np.in1d(self.data[:,self.exog],groups)]
t = ((data[:,self.endog]).astype(float)).astype(int)
tind = np.unique(t)
NK = []
N = []
D = []
Z = []
if rho != None and weight != None:
raise ValueError("Must use either rho or weights, not both")
elif rho != None:
s = KaplanMeier(data,self.endog,censoring=self.censoring)
s.fit()
s = (s.results[0][0]) ** (rho)
s = np.r_[1,s[:-1]]
elif weight != None:
s = weight(tind)
else:
s = np.ones_like(tind)
if self.censoring == None:
for g in groups:
dk = np.bincount((t[data[:,self.exog] == g]))
d = np.bincount(t)
if np.max(tind) != len(dk):
dif = np.max(tind) - len(dk) + 1
dk = np.r_[dk,[0]*dif]
dk = dk[:,list(tind)]
d = d[:,list(tind)]
dk = dk.astype(float)
d = d.astype(float)
dkSum = np.cumsum(dk)
dSum = np.cumsum(d)
dkSum = np.r_[0,dkSum]
dSum = np.r_[0,dSum]
nk = len(data[data[:,self.exog] == g]) - dkSum[:-1]
n = len(data) - dSum[:-1]
d = d[n>1]
dk = dk[n>1]
nk = nk[n>1]
n = n[n>1]
s = s[n>1]
ek = (nk * d)/(n)
Z.append(np.sum(s * (dk - ek)))
NK.append(nk)
N.append(n)
D.append(d)
else:
for g in groups:
censoring = ((data[:,self.censoring]).astype(float)).astype(int)
reverseCensoring = -1*(censoring - 1)
censored = np.bincount(t,reverseCensoring)
ck = np.bincount((t[data[:,self.exog] == g]),
reverseCensoring[data[:,self.exog] == g])
dk = np.bincount((t[data[:,self.exog] == g]),
censoring[data[:,self.exog] == g])
d = np.bincount(t,censoring)
if np.max(tind) != len(dk):
dif = np.max(tind) - len(dk) + 1
dk = np.r_[dk,[0]*dif]
ck = np.r_[ck,[0]*dif]
dk = dk[:,list(tind)]
ck = ck[:,list(tind)]
d = d[:,list(tind)]
dk = dk.astype(float)
d = d.astype(float)
ck = ck.astype(float)
dkSum = np.cumsum(dk)
dSum = np.cumsum(d)
ck = np.cumsum(ck)
ck = np.r_[0,ck]
dkSum = np.r_[0,dkSum]
dSum = np.r_[0,dSum]
censored = censored[:,list(tind)]
censored = censored.astype(float)
censoredSum = np.cumsum(censored)
censoredSum = np.r_[0,censoredSum]
nk = (len(data[data[:,self.exog] == g]) - dkSum[:-1]
- ck[:-1])
n = len(data) - dSum[:-1] - censoredSum[:-1]
d = d[n>1]
dk = dk[n>1]
nk = nk[n>1]
n = n[n>1]
s = s[n>1]
ek = (nk * d)/(n)
Z.append(np.sum(s * (dk - ek)))
NK.append(nk)
N.append(n)
D.append(d)
Z = np.array(Z)
N = np.array(N)
D = np.array(D)
NK = np.array(NK)
sigma = -1 * np.dot((NK/N) * ((N - D)/(N - 1)) * D
* np.array([(s ** 2)]*len(D))
,np.transpose(NK/N))
np.fill_diagonal(sigma, np.diagonal(np.dot((NK/N)
* ((N - D)/(N - 1)) * D
* np.array([(s ** 2)]*len(D))
,np.transpose(1 - (NK/N)))))
chisq = np.dot(np.transpose(Z),np.dot(la.pinv(sigma), Z))
df = len(groups) - 1
return np.array([chisq, df, stats.chi2.sf(chisq,df)])
else:
raise ValueError("groups must be in column exog")
| bsd-3-clause |
astropy/astropy | astropy/visualization/mpl_normalize.py | 5 | 15298 | """
Normalization class for Matplotlib that can be used to produce
colorbars.
"""
import inspect
import warnings
import numpy as np
from numpy import ma
from .interval import (PercentileInterval, AsymmetricPercentileInterval,
ManualInterval, MinMaxInterval, BaseInterval)
from .stretch import (LinearStretch, SqrtStretch, PowerStretch, LogStretch,
AsinhStretch, BaseStretch)
from ..utils.exceptions import AstropyDeprecationWarning
try:
import matplotlib # pylint: disable=W0611
from matplotlib.colors import Normalize
from matplotlib import pyplot as plt
except ImportError:
class Normalize:
def __init__(self, *args, **kwargs):
raise ImportError('matplotlib is required in order to use this '
'class.')
__all__ = ['ImageNormalize', 'simple_norm', 'imshow_norm']
__doctest_requires__ = {'*': ['matplotlib']}
class ImageNormalize(Normalize):
"""
Normalization class to be used with Matplotlib.
Parameters
----------
data : ndarray, optional
The image array. This input is used only if ``interval`` is
also input. ``data`` and ``interval`` are used to compute the
vmin and/or vmax values only if ``vmin`` or ``vmax`` are not
input.
interval : `~astropy.visualization.BaseInterval` subclass instance, optional
The interval object to apply to the input ``data`` to determine
the ``vmin`` and ``vmax`` values. This input is used only if
``data`` is also input. ``data`` and ``interval`` are used to
compute the vmin and/or vmax values only if ``vmin`` or ``vmax``
are not input.
vmin, vmax : float, optional
The minimum and maximum levels to show for the data. The
``vmin`` and ``vmax`` inputs override any calculated values from
the ``interval`` and ``data`` inputs.
stretch : `~astropy.visualization.BaseStretch` subclass instance
The stretch object to apply to the data. The default is
`~astropy.visualization.LinearStretch`.
clip : bool, optional
If `True`, data values outside the [0:1] range are clipped to
the [0:1] range.
invalid : None or float, optional
Value to assign NaN values generated by this class. NaNs in the
input ``data`` array are not changed. For matplotlib
normalization, the ``invalid`` value should map to the
matplotlib colormap "under" value (i.e., any finite value < 0).
If `None`, then NaN values are not replaced. This keyword has
no effect if ``clip=True``.
"""
def __init__(self, data=None, interval=None, vmin=None, vmax=None,
stretch=LinearStretch(), clip=False, invalid=-1.0):
# this super call checks for matplotlib
super().__init__(vmin=vmin, vmax=vmax, clip=clip)
self.vmin = vmin
self.vmax = vmax
if stretch is None:
raise ValueError('stretch must be input')
if not isinstance(stretch, BaseStretch):
raise TypeError('stretch must be an instance of a BaseStretch '
'subclass')
self.stretch = stretch
if interval is not None and not isinstance(interval, BaseInterval):
raise TypeError('interval must be an instance of a BaseInterval '
'subclass')
self.interval = interval
self.inverse_stretch = stretch.inverse
self.clip = clip
self.invalid = invalid
# Define vmin and vmax if not None and data was input
if data is not None:
self._set_limits(data)
def _set_limits(self, data):
if self.vmin is not None and self.vmax is not None:
return
# Define vmin and vmax from the interval class if not None
if self.interval is None:
if self.vmin is None:
self.vmin = np.min(data[np.isfinite(data)])
if self.vmax is None:
self.vmax = np.max(data[np.isfinite(data)])
else:
_vmin, _vmax = self.interval.get_limits(data)
if self.vmin is None:
self.vmin = _vmin
if self.vmax is None:
self.vmax = _vmax
def __call__(self, values, clip=None, invalid=None):
"""
Transform values using this normalization.
Parameters
----------
values : array-like
The input values.
clip : bool, optional
If `True`, values outside the [0:1] range are clipped to the
[0:1] range. If `None` then the ``clip`` value from the
`ImageNormalize` instance is used (the default of which is
`False`).
invalid : None or float, optional
Value to assign NaN values generated by this class. NaNs in
the input ``data`` array are not changed. For matplotlib
normalization, the ``invalid`` value should map to the
matplotlib colormap "under" value (i.e., any finite value <
0). If `None`, then the `ImageNormalize` instance value is
used. This keyword has no effect if ``clip=True``.
"""
if clip is None:
clip = self.clip
if invalid is None:
invalid = self.invalid
if isinstance(values, ma.MaskedArray):
if clip:
mask = False
else:
mask = values.mask
values = values.filled(self.vmax)
else:
mask = False
# Make sure scalars get broadcast to 1-d
if np.isscalar(values):
values = np.array([values], dtype=float)
else:
# copy because of in-place operations after
values = np.array(values, copy=True, dtype=float)
# Define vmin and vmax if not None
self._set_limits(values)
# Normalize based on vmin and vmax
np.subtract(values, self.vmin, out=values)
np.true_divide(values, self.vmax - self.vmin, out=values)
# Clip to the 0 to 1 range
if clip:
values = np.clip(values, 0., 1., out=values)
# Stretch values
if self.stretch._supports_invalid_kw:
values = self.stretch(values, out=values, clip=False,
invalid=invalid)
else:
values = self.stretch(values, out=values, clip=False)
# Convert to masked array for matplotlib
return ma.array(values, mask=mask)
def inverse(self, values, invalid=None):
# Find unstretched values in range 0 to 1
if self.inverse_stretch._supports_invalid_kw:
values_norm = self.inverse_stretch(values, clip=False,
invalid=invalid)
else:
values_norm = self.inverse_stretch(values, clip=False)
# Scale to original range
return values_norm * (self.vmax - self.vmin) + self.vmin
def simple_norm(data, stretch='linear', power=1.0, asinh_a=0.1, min_cut=None,
max_cut=None, min_percent=None, max_percent=None,
percent=None, clip=False, log_a=1000, invalid=-1.0):
"""
Return a Normalization class that can be used for displaying images
with Matplotlib.
This function enables only a subset of image stretching functions
available in `~astropy.visualization.mpl_normalize.ImageNormalize`.
This function is used by the
``astropy.visualization.scripts.fits2bitmap`` script.
Parameters
----------
data : ndarray
The image array.
stretch : {'linear', 'sqrt', 'power', log', 'asinh'}, optional
The stretch function to apply to the image. The default is
'linear'.
power : float, optional
The power index for ``stretch='power'``. The default is 1.0.
asinh_a : float, optional
For ``stretch='asinh'``, the value where the asinh curve
transitions from linear to logarithmic behavior, expressed as a
fraction of the normalized image. Must be in the range between
0 and 1. The default is 0.1.
min_cut : float, optional
The pixel value of the minimum cut level. Data values less than
``min_cut`` will set to ``min_cut`` before stretching the image.
The default is the image minimum. ``min_cut`` overrides
``min_percent``.
max_cut : float, optional
The pixel value of the maximum cut level. Data values greater
than ``min_cut`` will set to ``min_cut`` before stretching the
image. The default is the image maximum. ``max_cut`` overrides
``max_percent``.
min_percent : float, optional
The percentile value used to determine the pixel value of
minimum cut level. The default is 0.0. ``min_percent``
overrides ``percent``.
max_percent : float, optional
The percentile value used to determine the pixel value of
maximum cut level. The default is 100.0. ``max_percent``
overrides ``percent``.
percent : float, optional
The percentage of the image values used to determine the pixel
values of the minimum and maximum cut levels. The lower cut
level will set at the ``(100 - percent) / 2`` percentile, while
the upper cut level will be set at the ``(100 + percent) / 2``
percentile. The default is 100.0. ``percent`` is ignored if
either ``min_percent`` or ``max_percent`` is input.
clip : bool, optional
If `True`, data values outside the [0:1] range are clipped to
the [0:1] range.
log_a : float, optional
The log index for ``stretch='log'``. The default is 1000.
invalid : None or float, optional
Value to assign NaN values generated by the normalization. NaNs
in the input ``data`` array are not changed. For matplotlib
normalization, the ``invalid`` value should map to the
matplotlib colormap "under" value (i.e., any finite value < 0).
If `None`, then NaN values are not replaced. This keyword has
no effect if ``clip=True``.
Returns
-------
result : `ImageNormalize` instance
An `ImageNormalize` instance that can be used for displaying
images with Matplotlib.
"""
if percent is not None:
interval = PercentileInterval(percent)
elif min_percent is not None or max_percent is not None:
interval = AsymmetricPercentileInterval(min_percent or 0.,
max_percent or 100.)
elif min_cut is not None or max_cut is not None:
interval = ManualInterval(min_cut, max_cut)
else:
interval = MinMaxInterval()
if stretch == 'linear':
stretch = LinearStretch()
elif stretch == 'sqrt':
stretch = SqrtStretch()
elif stretch == 'power':
stretch = PowerStretch(power)
elif stretch == 'log':
stretch = LogStretch(log_a)
elif stretch == 'asinh':
stretch = AsinhStretch(asinh_a)
else:
raise ValueError(f'Unknown stretch: {stretch}.')
vmin, vmax = interval.get_limits(data)
return ImageNormalize(vmin=vmin, vmax=vmax, stretch=stretch, clip=clip,
invalid=invalid)
# used in imshow_norm
_norm_sig = inspect.signature(ImageNormalize)
def imshow_norm(data, ax=None, imshow_only_kwargs={}, **kwargs):
""" A convenience function to call matplotlib's `matplotlib.pyplot.imshow`
function, using an `ImageNormalize` object as the normalization.
Parameters
----------
data : 2D or 3D array-like
The data to show. Can be whatever `~matplotlib.pyplot.imshow` and
`ImageNormalize` both accept. See `~matplotlib.pyplot.imshow`.
ax : None or `~matplotlib.axes.Axes`, optional
If None, use pyplot's imshow. Otherwise, calls ``imshow`` method of
the supplied axes.
imshow_only_kwargs : dict, optional
Deprecated since Astropy v4.1. Note that settting both ``norm``
and ``vmin/vmax`` is deprecated in ``matplotlib >= 3.3``.
Arguments to be passed directly to `~matplotlib.pyplot.imshow` without
first trying `ImageNormalize`. This is only for keywords that have the
same name in both `ImageNormalize` and `~matplotlib.pyplot.imshow` - if
you want to set the `~matplotlib.pyplot.imshow` keywords only, supply
them in this dictionary.
kwargs : dict, optional
All other keyword arguments are parsed first by the
`ImageNormalize` initializer, then to
`~matplotlib.pyplot.imshow`.
Returns
-------
result : tuple
A tuple containing the `~matplotlib.image.AxesImage` generated
by `~matplotlib.pyplot.imshow` as well as the `ImageNormalize`
instance.
Notes
-----
The ``norm`` matplotlib keyword is not supported.
Examples
--------
.. plot::
:include-source:
import numpy as np
import matplotlib.pyplot as plt
from astropy.visualization import (imshow_norm, MinMaxInterval,
SqrtStretch)
# Generate and display a test image
image = np.arange(65536).reshape((256, 256))
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
im, norm = imshow_norm(image, ax, origin='lower',
interval=MinMaxInterval(),
stretch=SqrtStretch())
fig.colorbar(im)
"""
if imshow_only_kwargs:
warnings.warn('imshow_only_kwargs is deprecated since v4.1 and will '
'be removed in a future version.',
AstropyDeprecationWarning)
if 'X' in kwargs:
raise ValueError('Cannot give both ``X`` and ``data``')
if 'norm' in kwargs:
raise ValueError('There is no point in using imshow_norm if you give '
'the ``norm`` keyword - use imshow directly if you '
'want that.')
imshow_kwargs = dict(kwargs)
norm_kwargs = {'data': data}
for pname in _norm_sig.parameters:
if pname in kwargs:
norm_kwargs[pname] = imshow_kwargs.pop(pname)
for k, v in imshow_only_kwargs.items():
if k not in _norm_sig.parameters:
# the below is not strictly "has to be true", but is here so that
# users don't start using both imshow_only_kwargs *and* keyword
# arguments to this function, as that makes for more confusing
# user code
raise ValueError('You provided a keyword to imshow_only_kwargs '
'({}) that is not a keyword for ImageNormalize. '
'This is not supported. Instead you should '
'pass the keyword directly into imshow_norm'
.format(k))
imshow_kwargs[k] = v
imshow_kwargs['norm'] = ImageNormalize(**norm_kwargs)
if ax is None:
imshow_result = plt.imshow(data, **imshow_kwargs)
else:
imshow_result = ax.imshow(data, **imshow_kwargs)
return imshow_result, imshow_kwargs['norm']
| bsd-3-clause |
zuotingbing/spark | python/pyspark/testing/sqlutils.py | 9 | 7813 | #
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import datetime
import os
import shutil
import tempfile
from contextlib import contextmanager
from pyspark.sql import SparkSession
from pyspark.sql.types import ArrayType, DoubleType, UserDefinedType, Row
from pyspark.testing.utils import ReusedPySparkTestCase
from pyspark.util import _exception_message
pandas_requirement_message = None
try:
from pyspark.sql.pandas.utils import require_minimum_pandas_version
require_minimum_pandas_version()
except ImportError as e:
# If Pandas version requirement is not satisfied, skip related tests.
pandas_requirement_message = _exception_message(e)
pyarrow_requirement_message = None
try:
from pyspark.sql.pandas.utils import require_minimum_pyarrow_version
require_minimum_pyarrow_version()
except ImportError as e:
# If Arrow version requirement is not satisfied, skip related tests.
pyarrow_requirement_message = _exception_message(e)
test_not_compiled_message = None
try:
from pyspark.sql.utils import require_test_compiled
require_test_compiled()
except Exception as e:
test_not_compiled_message = _exception_message(e)
have_pandas = pandas_requirement_message is None
have_pyarrow = pyarrow_requirement_message is None
test_compiled = test_not_compiled_message is None
class UTCOffsetTimezone(datetime.tzinfo):
"""
Specifies timezone in UTC offset
"""
def __init__(self, offset=0):
self.ZERO = datetime.timedelta(hours=offset)
def utcoffset(self, dt):
return self.ZERO
def dst(self, dt):
return self.ZERO
class ExamplePointUDT(UserDefinedType):
"""
User-defined type (UDT) for ExamplePoint.
"""
@classmethod
def sqlType(self):
return ArrayType(DoubleType(), False)
@classmethod
def module(cls):
return 'pyspark.sql.tests'
@classmethod
def scalaUDT(cls):
return 'org.apache.spark.sql.test.ExamplePointUDT'
def serialize(self, obj):
return [obj.x, obj.y]
def deserialize(self, datum):
return ExamplePoint(datum[0], datum[1])
class ExamplePoint:
"""
An example class to demonstrate UDT in Scala, Java, and Python.
"""
__UDT__ = ExamplePointUDT()
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return "ExamplePoint(%s,%s)" % (self.x, self.y)
def __str__(self):
return "(%s,%s)" % (self.x, self.y)
def __eq__(self, other):
return isinstance(other, self.__class__) and \
other.x == self.x and other.y == self.y
class PythonOnlyUDT(UserDefinedType):
"""
User-defined type (UDT) for ExamplePoint.
"""
@classmethod
def sqlType(self):
return ArrayType(DoubleType(), False)
@classmethod
def module(cls):
return '__main__'
def serialize(self, obj):
return [obj.x, obj.y]
def deserialize(self, datum):
return PythonOnlyPoint(datum[0], datum[1])
@staticmethod
def foo():
pass
@property
def props(self):
return {}
class PythonOnlyPoint(ExamplePoint):
"""
An example class to demonstrate UDT in only Python
"""
__UDT__ = PythonOnlyUDT()
class MyObject(object):
def __init__(self, key, value):
self.key = key
self.value = value
class SQLTestUtils(object):
"""
This util assumes the instance of this to have 'spark' attribute, having a spark session.
It is usually used with 'ReusedSQLTestCase' class but can be used if you feel sure the
the implementation of this class has 'spark' attribute.
"""
@contextmanager
def sql_conf(self, pairs):
"""
A convenient context manager to test some configuration specific logic. This sets
`value` to the configuration `key` and then restores it back when it exits.
"""
assert isinstance(pairs, dict), "pairs should be a dictionary."
assert hasattr(self, "spark"), "it should have 'spark' attribute, having a spark session."
keys = pairs.keys()
new_values = pairs.values()
old_values = [self.spark.conf.get(key, None) for key in keys]
for key, new_value in zip(keys, new_values):
self.spark.conf.set(key, new_value)
try:
yield
finally:
for key, old_value in zip(keys, old_values):
if old_value is None:
self.spark.conf.unset(key)
else:
self.spark.conf.set(key, old_value)
@contextmanager
def database(self, *databases):
"""
A convenient context manager to test with some specific databases. This drops the given
databases if it exists and sets current database to "default" when it exits.
"""
assert hasattr(self, "spark"), "it should have 'spark' attribute, having a spark session."
try:
yield
finally:
for db in databases:
self.spark.sql("DROP DATABASE IF EXISTS %s CASCADE" % db)
self.spark.catalog.setCurrentDatabase("default")
@contextmanager
def table(self, *tables):
"""
A convenient context manager to test with some specific tables. This drops the given tables
if it exists.
"""
assert hasattr(self, "spark"), "it should have 'spark' attribute, having a spark session."
try:
yield
finally:
for t in tables:
self.spark.sql("DROP TABLE IF EXISTS %s" % t)
@contextmanager
def tempView(self, *views):
"""
A convenient context manager to test with some specific views. This drops the given views
if it exists.
"""
assert hasattr(self, "spark"), "it should have 'spark' attribute, having a spark session."
try:
yield
finally:
for v in views:
self.spark.catalog.dropTempView(v)
@contextmanager
def function(self, *functions):
"""
A convenient context manager to test with some specific functions. This drops the given
functions if it exists.
"""
assert hasattr(self, "spark"), "it should have 'spark' attribute, having a spark session."
try:
yield
finally:
for f in functions:
self.spark.sql("DROP FUNCTION IF EXISTS %s" % f)
class ReusedSQLTestCase(ReusedPySparkTestCase, SQLTestUtils):
@classmethod
def setUpClass(cls):
super(ReusedSQLTestCase, cls).setUpClass()
cls.spark = SparkSession(cls.sc)
cls.tempdir = tempfile.NamedTemporaryFile(delete=False)
os.unlink(cls.tempdir.name)
cls.testData = [Row(key=i, value=str(i)) for i in range(100)]
cls.df = cls.spark.createDataFrame(cls.testData)
@classmethod
def tearDownClass(cls):
super(ReusedSQLTestCase, cls).tearDownClass()
cls.spark.stop()
shutil.rmtree(cls.tempdir.name, ignore_errors=True)
| apache-2.0 |
gcallah/Indra | setup.py | 1 | 1286 | from setuptools import setup, find_packages
setup(name='indras_net',
version='2.0.6',
description='A framework for agent-based modeling in Python.',
url='https://github.com/gcallah/indras_net.git',
author='Gene Callahan and Nathan Conroy',
author_email='[email protected]',
license='GNU',
zip_safe=False,
packages=find_packages(exclude=["*.tests", "*.tests.*", "tests.*",
"tests"]),
install_requires=[
"networkx",
"numpy", 'propargs', 'matplotlib'
],
test_suite="",
entry_points={
"console_scripts": ['indra = indra.__main__:main']
},
classifiers=[
# How mature is this project? Common values are
# 3 - Alpha
# 4 - Beta
# 5 - Production/Stable
'Development Status :: 4 - Beta',
# Indicate who your project is intended for
'Intended Audience :: Developers',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
],
)
| gpl-3.0 |
gbrammer/grizli | grizli/galfit/deconvolve.py | 1 | 15242 | #!/usr/bin/env python
# encoding: utf-8
"""
deconvolve.py
GALFIT "deconvolution" as in Szomoru et al.
https://iopscience.iop.org/article/10.1088/2041-8205/714/2/L244
"""
import numpy as np
import astropy.io.fits as pyfits
import astropy.stats
import astropy.table
def test():
im = pyfits.open('/tmp/gf_out.fits')
model_hdu = im[2]
residuals = im[3].data
_x = galfit_deconvolve(model_hdu, residuals, rms=None)
model_hdu = _x['model']
residuals = _x['resid'].data
imshow_args = {'vmin': -5, 'vmax': 5, 'cmap': 'viridis'}
_ = galfit_deconvolve(model_hdu, residuals, rms=_x['rms'], imshow_args=imshow_args)
def galfit_deconvolve(model_hdu, residuals, rms=None, mask=None, oversample=8, comp='1', xprof=np.append(0, np.arange(2, 20)), y_func=np.mean, cumul_values=[0.5, 0.8], make_plot=True, imshow_args={'vmin': -5, 'vmax': 5, 'cmap': 'viridis'}, plt_kwargs={'linestyle': 'steps-mid', 'color': 'r', 'alpha': 0.8}, npix=20, psf_offset=[1, 1]):
"""
Deconvolve an image using a galfit Sersic model
`model_hdu` is the HDU output from GALFIT containing the model and model
parameters (e.g, out.fits[2]).
`residuals` are the fit residuals (out.fits[3].data)
`psf_offset` is the offset of the PSF relative to the central pixel of
the PSF array.
Returns:
R = radii evaluated at pixel positions for the ellipse parameters
phi = position angle around the ellipse, radians
prof = 2D array of unconvolved Sersic profile
params = Galfit params
tab = table of the 1D profile
fig = optional figure if `make_plot=True`
"""
import matplotlib.pyplot as plt
#model_hdu = _x['model']
#residuals = _x['resid']
_h = model_hdu.header
shape = residuals.shape
if mask is None:
mask = np.isfinite(residuals)
# Ellipse parameters and sersic profile
R, phi, prof, params = sersic_profile(shape, oversample=oversample,
gf_header=_h, comp=comp,
psf_offset=psf_offset)
so = np.argsort(R[mask].flatten())
Rso = R[mask].flatten()[so]
data = residuals + model_hdu.data
if '1_SKY' in _h:
sky = gf_header_key(_h, '1_SKY')
else:
sky = 0.
##########
# 1D averaged profiles
integ = False
# Original data
_, ydata, _, _ = running_median(Rso,
(data)[mask].flatten()[so].astype(np.float)-sky,
bins=xprof, use_median=False, y_func=y_func, integrate=integ)
# Convolved model
_, ymodel, _, _ = running_median(Rso,
(model_hdu.data)[mask].flatten()[so].astype(np.float),
bins=xprof, use_median=False, y_func=y_func, integrate=integ)
# Sersic profile
_, yprof, _, _ = running_median(Rso,
(prof)[mask].flatten()[so].astype(np.float),
bins=xprof, use_median=False, y_func=y_func, integrate=integ)
# Sersic + residuals
xm, ydeconv, ys, yn = running_median(Rso,
(prof + residuals)[mask].flatten()[so].astype(np.float),
bins=xprof, use_median=False, y_func=y_func, integrate=integ)
# Sum for total normalizatioin
_, ydeconv_sum, _, _ = running_median(Rso,
(prof + residuals)[mask].flatten()[so].astype(np.float),
bins=xprof, use_median=False, y_func=np.sum, integrate=False)
# Variance
if rms is not None:
xmx, yv, yvs, yn = running_median(Rso,
rms[mask].flatten()[so].astype(np.float)**2,
bins=xprof, use_median=False, y_func=np.sum)
yrms = np.sqrt(yv)/yn
im_norm = rms
# weighted
xmx, ynum_model, yvs, yn = running_median(Rso,
(model_hdu.data/rms**2)[mask].flatten()[so].astype(np.float),
bins=xprof, use_median=False, y_func=np.sum)
xmx, ynum, yvs, yn = running_median(Rso,
(data/rms**2)[mask].flatten()[so].astype(np.float),
bins=xprof, use_median=False, y_func=np.sum)
xmx, yden, yvs, yn = running_median(Rso,
(1./rms**2)[mask].flatten()[so].astype(np.float),
bins=xprof, use_median=False, y_func=np.sum)
yweight = ynum/yden
yweight_model = ynum_model/yden
yweight_err = 1./np.sqrt(yden)
else:
yrms = ys
im_norm = 1
yweight = None
dx = np.diff(xprof)
xpix = xprof[1:]-dx/2.
if False:
# Scale
yscl = 1.
#yscl = prof[msk].sum()/np.trapz(2*np.pi*yprof*xpix, xpix)
yprof *= yscl
ydeconv *= yscl
yrms *= yscl
# Interpolate Radii from the cumulative flux distribution
cumul_flux = np.cumsum((prof + residuals)[mask].flatten()[so])
#total = cumflux.max()
total = ydeconv_sum.sum()
Rcumul = np.interp(cumul_values, cumul_flux/total, Rso)
tab = astropy.table.Table()
tab['xpix'] = xpix
tab['yprofile'] = yprof
tab['ydeconv'] = ydeconv
tab['yrms'] = yrms
tab['ydata'] = ydata
tab['ymodel'] = ymodel
if yweight is not None:
tab['yweight'] = yweight
tab['yweight_model'] = yweight_model
tab['yweight_err'] = yweight_err
tab.meta['total_flux'] = total
for k in params:
tab.meta[k] = params[k]
for i, r in enumerate(cumul_values):
tab.meta['R{0}'.format(int(r*100))] = Rcumul[i]
params['Rcumul'] = Rcumul
if make_plot:
fig = plt.figure(figsize=(12, 3))
ax = fig.add_subplot(141)
ax2 = fig.add_subplot(142)
ax3 = fig.add_subplot(143)
ax4 = fig.add_subplot(144)
ax4.loglog()
ax4.grid()
xc = gf_header_key(_h, comp+'_XC')
yc = gf_header_key(_h, comp+'_YC')
ax.imshow(data/im_norm*mask, **imshow_args)
ax2.imshow(residuals/im_norm*mask, **imshow_args)
ax3.imshow(prof/im_norm*mask, **imshow_args)
label = 'Re={re:.2f}, n={n:.1f}'.format(**params)
pl = ax4.plot(xpix, yprof, label=label, **plt_kwargs)
ax4.errorbar(xpix, ydeconv, yrms, linestyle='None',
color=pl[0].get_color(), alpha=0.5, marker='.')
ax4.vlines(params['re'], 1e-10, 1e10, color=pl[0].get_color(), alpha=0.5)
ax4.vlines(Rcumul, 1e-10, 1e10, color=pl[0].get_color(), alpha=0.5, linewidth=3, linestyle='--')
ax4.scatter(Rso,
(prof + residuals)[mask].flatten()[so].astype(np.float)-sky,
marker='.', color='k', alpha=0.1, zorder=-1000)
# ax4.scatter(Rso,
# (data)[mask].flatten()[so].astype(np.float)-sky,
# marker='.', color='r', alpha=0.1, zorder=-1000)
ax4.legend()
valid = np.isfinite(ydeconv) & np.isfinite(yprof)
print(ydeconv[valid].min(), ydeconv[valid].max())
try:
ax4.set_ylim(np.maximum(0.5*yprof[valid].min(), 1e-5*ydeconv[valid].max()),
2*ydeconv[valid].max())
except:
pass
ax4.set_xlim(0.05, xprof.max()+2)
for a in [ax, ax2, ax3]:
a.set_xlim(xc-1-npix, xc-1+npix)
a.set_ylim(yc-1-npix, yc-1+npix)
a.set_xticklabels([])
a.set_yticklabels([])
# Show ellipses on images
a.plot(*r_ellipse(Rcumul[0], psf_offset=psf_offset, **params),
color='w', alpha=0.9, linewidth=2)
a.plot(*r_ellipse(xpix.max(), psf_offset=psf_offset, **params),
color='w', alpha=0.9, linewidth=2)
a.plot(*r_ellipse(Rcumul[0], psf_offset=psf_offset, **params),
color=pl[0].get_color(), alpha=0.5)
a.plot(*r_ellipse(xpix.max(), psf_offset=psf_offset, **params),
color=pl[0].get_color(), alpha=0.5, linestyle='--')
fig.tight_layout(pad=0.1)
else:
fig = None
return R, phi, prof, params, tab, fig
def get_kappa(n, **kwargs):
"""
Compute the Kappa parameter for a given n index as in the Galfit
definition
"""
from scipy.optimize import root
x0 = 2*n-0.33
args = (n)
k = root(kappa_func, x0, args=args, **kwargs)
return k.x[0]
def kappa_func(kappa, n):
"""
Function for getting Sersic kappa
"""
from scipy.special import gamma, gammainc
f = gamma(2*n)-2*gammainc(2*n, kappa)*gamma(2*n)
return f
def Rc(c0):
"""
Shape parameter
"""
from scipy.special import beta
return np.pi*(c0+2)/(4*beta(1./(c0+2), 1+1./(c0+2)))
def sigma_e(re, n, q, Ftot=1., c0=0.):
"""
Surface brightess at the effective radius, re, given total flux
"""
from scipy.special import gamma
kap = get_kappa(n)
return Ftot/(2*np.pi*re**2*np.exp(kap)*n*kap**(-2*n)*gamma(2*n)*q/Rc(c0)), kap
def gf_header_key(header, key='2_XC'):
"""
Get a header keyword from a GALFIT header, which may have [] and *
in the keyword value
"""
return float(header[key].split()[0].strip('[]').strip('*').strip('{').strip('}'))
def sersic_profile(shape, mag=20., xc=[0., 0.], n=1., q=0.5, pa=0, re=1., ZP=26., gf_header=None, comp='2', verbose=True, oversample=8, psf_offset=[1, 1]):
"""
Generate a Sersic profile with Galfit parameters within a defined image
shape.
Specify the parameters individually or provide a GALFIT model header
gf_header: FITS header of a GALFIT output model
comp: Number of the object in the GALFIT model
"""
import scipy.ndimage as nd
if gf_header is not None:
xx = gf_header_key(gf_header, comp+'_XC')
yy = gf_header_key(gf_header, comp+'_YC')
xc = np.array([xx, yy])
mag = gf_header_key(gf_header, comp+'_MAG')
if comp+'_N' in gf_header:
n = gf_header_key(gf_header, comp+'_N')
q = gf_header_key(gf_header, comp+'_AR')
pa = gf_header_key(gf_header, comp+'_PA')
re = gf_header_key(gf_header, comp+'_RE')
else:
n = 1.
q = 1.
pa = 0.
re = 0.01
if verbose:
print(f'xc:{xc}, q:{q}, pa:{pa}, n:{n}')
if 'MAGZPT' in gf_header:
ZP = gf_header['MAGZPT']
params = {'mag': mag, 'xc': xc, 're': re, 'n': n, 'q': q, 'pa': pa}
sigm, kap = sigma_e(re, n, q)
norm = sigm*10**(-0.4*(mag-ZP))
R, x, phi = pix_to_r(shape, verbose=verbose, psf_offset=psf_offset,
**params)
if oversample > 1:
Ro, x, phio = pix_to_r(shape, oversample=oversample, verbose=verbose,
psf_offset=psf_offset, **params)
sersic_large = norm*np.exp(-kap*((Ro/re)**(1./n)-1))
kern = np.ones((oversample, oversample))/oversample**2
sersic_profile = nd.convolve(sersic_large, kern)[oversample//2-1::oversample, oversample//2-1::oversample]
else:
sersic_profile = norm*np.exp(-kap*((R/re)**(1./n)-1))
return R, phi, sersic_profile, params
def r_ellipse(radius=5, xc=[0., 0.], q=0.5, pa=0, re=1., gf_header=None, comp='2', verbose=True, nstep=256, psf_offset=[1, 1], **kwargs):
"""
Make x, y coordinates given ellipse parameters
"""
if gf_header is not None:
xx = gf_header_key(gf_header, comp+'_XC')
yy = gf_header_key(gf_header, comp+'_YC')
xc = np.array([xx, yy])
mag = gf_header_key(gf_header, comp+'_MAG')
if comp+'_N' in gf_header:
n = gf_header_key(gf_header, comp+'_N')
q = gf_header_key(gf_header, comp+'_AR')
pa = gf_header_key(gf_header, comp+'_PA')
re = gf_header_key(gf_header, comp+'_RE')
else:
n = 1.
q = 1.
pa = 0.
re = 0.01
if verbose:
print(f'xc:{xc}, q:{q}, pa:{pa}')
phi = np.linspace(0, 2*np.pi, nstep)
xp = np.array([np.cos(phi), q*np.sin(phi)]).T*radius
theta = -(np.pi/2 + pa/180*np.pi) # + np.pi
_rot = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]])
x0 = xp.dot(_rot) + np.atleast_1d(xc)
xell, yell = (x0 - 1 - np.atleast_1d(psf_offset)).T
return xell, yell
def pix_to_r(shape, xc=[0., 0.], q=0.5, pa=0, re=1., gf_header=None, comp='2', verbose=True, oversample=1, psf_offset=[1, 1], **kwargs):
"""
Return an array of ellipse radii for a pixel grid and ellipse parameters
"""
if oversample > 1:
xarr = np.arange(-0.5, shape[1]-0.5, 1/oversample)
yarr = np.arange(-0.5, shape[0]-0.5, 1/oversample)
else:
xarr = np.arange(0, shape[1], 1/oversample)
yarr = np.arange(0, shape[0], 1/oversample)
x0 = np.array(np.meshgrid(xarr, yarr)).reshape((2, -1)).T + 1
x0 += np.atleast_1d(psf_offset)
if gf_header is not None:
xx = gf_header_key(gf_header, comp+'_XC')
yy = gf_header_key(gf_header, comp+'_YC')
xc = np.array([xx, yy])
mag = gf_header_key(gf_header, comp+'_MAG')
if comp+'_N' in gf_header:
n = gf_header_key(gf_header, comp+'_N')
q = gf_header_key(gf_header, comp+'_AR')
pa = gf_header_key(gf_header, comp+'_PA')
re = gf_header_key(gf_header, comp+'_RE')
else:
n = 1.
q = 1.
pa = 0.
re = 0.01
if verbose:
print(f'xc:{xc}, q:{q}, pa:{pa}')
theta = (np.pi/2 + pa/180*np.pi) # + np.pi
_rot = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]])
xp = (x0 - np.atleast_1d(xc)).dot(_rot)
outshape = [s*oversample for s in shape]
R = np.sqrt(((xp/np.array([1, q]))**2).sum(axis=1)).reshape(outshape)
phi = np.arctan2(xp[:, 1], xp[:, 0]).reshape(outshape)
return R, re, phi
def running_median(xi, yi, NBIN=10, use_median=True, use_nmad=True, reverse=False, bins=None, x_func=astropy.stats.biweight_location, y_func=astropy.stats.biweight_location, std_func=astropy.stats.biweight_midvariance, integrate=False):
"""
Running median/biweight/nmad
"""
NPER = xi.size // NBIN
if bins is None:
so = np.argsort(xi)
if reverse:
so = so[::-1]
bx = np.linspace(0, len(xi), NBIN+1)
bins = np.interp(bx, np.arange(len(xi)), xi[so])
if reverse:
bins = bins[::-1]
NBIN = len(bins)-1
xm = np.arange(NBIN)*1.
xs = xm*0
ym = xm*0
ys = xm*0
N = np.arange(NBIN)
if use_median:
y_func = np.median
if use_nmad:
std_func = astropy.stats.mad_std
for i in range(NBIN):
in_bin = (xi > bins[i]) & (xi <= bins[i+1])
N[i] = in_bin.sum() # N[i] = xi[so][idx+NPER*i].size
if integrate:
xso = np.argsort(xi[in_bin])
ma = xi[in_bin].max()
mi = xi[in_bin].min()
xm[i] = (ma+mi)/2.
dx = (ma-mi)
ym[i] = np.trapz(yi[in_bin][xso], xi[in_bin][xso])/dx
else:
xm[i] = x_func(xi[in_bin])
ym[i] = y_func(yi[in_bin])
ys[i] = std_func(yi[in_bin])
return xm, ym, ys, N
| mit |
abhi007tyagi/JARVIS | Python/JarvisBrain/trainer.py | 1 | 5819 | import nltk
from nltk.tokenize import word_tokenize
import random
from nltk.classify.scikitlearn import SklearnClassifier
import pickle
from sklearn.naive_bayes import MultinomialNB, BernoulliNB
from sklearn.linear_model import LogisticRegression, SGDClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
print("Reading training corpus...")
welcome = open("raw/welcome.txt", "r").read()
command = open("raw/commands.txt", "r").read()
maths = open("raw/maths.txt", "r").read()
random_things = open("raw/random.txt", "r").read()
print("Building documents and words...")
all_words = []
documents = []
# j is adject, r is adverb, and v is verb
allowed_word_types = ["J", "R", "V", "N", "CD"]
for wel in welcome.split("\n"):
documents.append((wel, "wel"))
words = word_tokenize(wel)
pos = nltk.pos_tag(words)
for w in pos:
if w[1][0] in allowed_word_types:
all_words.append(w[0].lower())
for cmd in command.split("\n"):
documents.append((cmd, "cmd"))
words = word_tokenize(cmd)
pos = nltk.pos_tag(words)
for w in pos:
if w[1][0] in allowed_word_types:
all_words.append(w[0].lower())
for mth in maths.split("\n"):
documents.append((mth, "mth"))
words = word_tokenize(mth)
pos = nltk.pos_tag(words)
for w in pos:
if w[1][0] in allowed_word_types:
all_words.append(w[0].lower())
# for rand in random_things.split("\n"):
# documents.append((rand, "rand"))
# words = word_tokenize(rand)
# pos = nltk.pos_tag(words)
# for w in pos:
# if w[1][0] in allowed_word_types:
# all_words.append(w[0].lower())
print("Saving documents...")
save_documents = open("pickled/documents.pickle", "wb")
pickle.dump(documents, save_documents)
save_documents.close()
all_words = nltk.FreqDist(all_words)
word_features = list(all_words.keys())
print("Saving words...")
save_word_features = open("pickled/word_features.pickle", "wb")
pickle.dump(word_features, save_word_features)
save_word_features.close()
def find_features(document):
words = word_tokenize(document)
features = {}
for w in word_features:
features[w] = (w in words)
return features
featuresets = [(find_features(rev), category) for (rev, category) in documents]
random.shuffle(featuresets)
random.shuffle(featuresets)
random.shuffle(featuresets)
random.shuffle(featuresets)
save_featureset = open("pickled/featuresets.pickle", "wb")
pickle.dump(featuresets, save_featureset)
save_featureset.close()
# print(featuresets)
print("Feature-set created of length ->", len(featuresets))
training_set = featuresets[:180]
testing_set = featuresets[180:]
print("Starting training different algorithms...")
orig_classifier = nltk.NaiveBayesClassifier.train(training_set)
print("Original_classifier Accuracy ->", (nltk.classify.accuracy(orig_classifier, testing_set)) * 100)
# orig_classifier.show_most_informative_features()
save_classifier = open("pickled/originalnaivebayes.pickle", "wb")
pickle.dump(orig_classifier, save_classifier)
save_classifier.close()
## Different classifiers are used at the moment. During code optimization, only the required classifier/s will be used.
MNB_classifier = SklearnClassifier(MultinomialNB())
MNB_classifier.train(training_set)
print("MNB_classifier Accuracy ->", (nltk.classify.accuracy(MNB_classifier, testing_set)) * 100)
save_classifier = open("pickled/MNB_classifier.pickle", "wb")
pickle.dump(MNB_classifier, save_classifier)
save_classifier.close()
BernoulliNB_classifier = SklearnClassifier(BernoulliNB())
BernoulliNB_classifier.train(training_set)
print("BernoulliNB_classifier Accuracy ->", (nltk.classify.accuracy(BernoulliNB_classifier, testing_set)) * 100)
save_classifier = open("pickled/BernoulliNB_classifier.pickle", "wb")
pickle.dump(BernoulliNB_classifier, save_classifier)
save_classifier.close()
LogisticRegression_classifier = SklearnClassifier(LogisticRegression())
LogisticRegression_classifier.train(training_set)
print("LogisticRegression_classifier Accuracy ->",
(nltk.classify.accuracy(LogisticRegression_classifier, testing_set)) * 100)
save_classifier = open("pickled/LogisticRegression_classifier.pickle", "wb")
pickle.dump(LogisticRegression_classifier, save_classifier)
save_classifier.close()
SGDClassifier_classifier = SklearnClassifier(SGDClassifier())
SGDClassifier_classifier.train(training_set)
print("SGDClassifier_classifier Accuracy ->", (nltk.classify.accuracy(SGDClassifier_classifier, testing_set)) * 100)
save_classifier = open("pickled/SGDC_classifier.pickle", "wb")
pickle.dump(SGDClassifier_classifier, save_classifier)
save_classifier.close()
# SVC_classifier = SklearnClassifier(SVC())
# SVC_classifier.train(training_set)
# print("SVC_classifier Accuracy ->", (nltk.classify.accuracy(SVC_classifier, testing_set))*100)
LinearSVC_classifier = SklearnClassifier(LinearSVC())
LinearSVC_classifier.train(training_set)
print("LinearSVC_classifier Accuracy ->", (nltk.classify.accuracy(LinearSVC_classifier, testing_set)) * 100)
save_classifier = open("pickled/LinearSVC_classifier.pickle", "wb")
pickle.dump(LinearSVC_classifier, save_classifier)
save_classifier.close()
NuSVC_classifier = SklearnClassifier(NuSVC())
NuSVC_classifier.train(training_set)
print("NuSVC_classifier Accuracy ->", (nltk.classify.accuracy(NuSVC_classifier, testing_set)) * 100)
save_classifier = open("pickled/NuSVC_classifier.pickle", "wb")
pickle.dump(NuSVC_classifier, save_classifier)
save_classifier.close()
#
# # custom_classifier = CustomClassifier(SGDClassifier, LinearSVC_classifier, LogisticRegression_classifier,
# # BernoulliNB_classifier, MNB_classifier)
# # print("Custom_classifier Accuracy ->", (nltk.classify.accuracy(custom_classifier, testing_set)) * 100)
| apache-2.0 |
DGrady/pandas | pandas/tests/io/parser/python_parser_only.py | 9 | 8017 | # -*- coding: utf-8 -*-
"""
Tests that apply specifically to the Python parser. Unless specifically
stated as a Python-specific issue, the goal is to eventually move as many of
these tests out of this module as soon as the C parser can accept further
arguments when parsing.
"""
import csv
import pytest
import pandas.util.testing as tm
from pandas import DataFrame, Index
from pandas import compat
from pandas.errors import ParserError
from pandas.compat import StringIO, BytesIO, u
class PythonParserTests(object):
def test_invalid_skipfooter(self):
text = "a\n1\n2"
# see gh-15925 (comment)
msg = "skipfooter must be an integer"
with tm.assert_raises_regex(ValueError, msg):
self.read_csv(StringIO(text), skipfooter="foo")
with tm.assert_raises_regex(ValueError, msg):
self.read_csv(StringIO(text), skipfooter=1.5)
with tm.assert_raises_regex(ValueError, msg):
self.read_csv(StringIO(text), skipfooter=True)
msg = "skipfooter cannot be negative"
with tm.assert_raises_regex(ValueError, msg):
self.read_csv(StringIO(text), skipfooter=-1)
def test_sniff_delimiter(self):
text = """index|A|B|C
foo|1|2|3
bar|4|5|6
baz|7|8|9
"""
data = self.read_csv(StringIO(text), index_col=0, sep=None)
tm.assert_index_equal(data.index,
Index(['foo', 'bar', 'baz'], name='index'))
data2 = self.read_csv(StringIO(text), index_col=0, delimiter='|')
tm.assert_frame_equal(data, data2)
text = """ignore this
ignore this too
index|A|B|C
foo|1|2|3
bar|4|5|6
baz|7|8|9
"""
data3 = self.read_csv(StringIO(text), index_col=0,
sep=None, skiprows=2)
tm.assert_frame_equal(data, data3)
text = u("""ignore this
ignore this too
index|A|B|C
foo|1|2|3
bar|4|5|6
baz|7|8|9
""").encode('utf-8')
s = BytesIO(text)
if compat.PY3:
# somewhat False since the code never sees bytes
from io import TextIOWrapper
s = TextIOWrapper(s, encoding='utf-8')
data4 = self.read_csv(s, index_col=0, sep=None, skiprows=2,
encoding='utf-8')
tm.assert_frame_equal(data, data4)
def test_BytesIO_input(self):
if not compat.PY3:
pytest.skip(
"Bytes-related test - only needs to work on Python 3")
data = BytesIO("שלום::1234\n562::123".encode('cp1255'))
result = self.read_table(data, sep="::", encoding='cp1255')
expected = DataFrame([[562, 123]], columns=["שלום", "1234"])
tm.assert_frame_equal(result, expected)
def test_single_line(self):
# see gh-6607: sniff separator
df = self.read_csv(StringIO('1,2'), names=['a', 'b'],
header=None, sep=None)
tm.assert_frame_equal(DataFrame({'a': [1], 'b': [2]}), df)
def test_skipfooter(self):
# see gh-6607
data = """A,B,C
1,2,3
4,5,6
7,8,9
want to skip this
also also skip this
"""
result = self.read_csv(StringIO(data), skipfooter=2)
no_footer = '\n'.join(data.split('\n')[:-3])
expected = self.read_csv(StringIO(no_footer))
tm.assert_frame_equal(result, expected)
result = self.read_csv(StringIO(data), nrows=3)
tm.assert_frame_equal(result, expected)
# skipfooter alias
result = self.read_csv(StringIO(data), skipfooter=2)
no_footer = '\n'.join(data.split('\n')[:-3])
expected = self.read_csv(StringIO(no_footer))
tm.assert_frame_equal(result, expected)
def test_decompression_regex_sep(self):
# see gh-6607
try:
import gzip
import bz2
except ImportError:
pytest.skip('need gzip and bz2 to run')
with open(self.csv1, 'rb') as f:
data = f.read()
data = data.replace(b',', b'::')
expected = self.read_csv(self.csv1)
with tm.ensure_clean() as path:
tmp = gzip.GzipFile(path, mode='wb')
tmp.write(data)
tmp.close()
result = self.read_csv(path, sep='::', compression='gzip')
tm.assert_frame_equal(result, expected)
with tm.ensure_clean() as path:
tmp = bz2.BZ2File(path, mode='wb')
tmp.write(data)
tmp.close()
result = self.read_csv(path, sep='::', compression='bz2')
tm.assert_frame_equal(result, expected)
pytest.raises(ValueError, self.read_csv,
path, compression='bz3')
def test_read_table_buglet_4x_multiindex(self):
# see gh-6607
text = """ A B C D E
one two three four
a b 10.0032 5 -0.5109 -2.3358 -0.4645 0.05076 0.3640
a q 20 4 0.4473 1.4152 0.2834 1.00661 0.1744
x q 30 3 -0.6662 -0.5243 -0.3580 0.89145 2.5838"""
df = self.read_table(StringIO(text), sep=r'\s+')
assert df.index.names == ('one', 'two', 'three', 'four')
# see gh-6893
data = ' A B C\na b c\n1 3 7 0 3 6\n3 1 4 1 5 9'
expected = DataFrame.from_records(
[(1, 3, 7, 0, 3, 6), (3, 1, 4, 1, 5, 9)],
columns=list('abcABC'), index=list('abc'))
actual = self.read_table(StringIO(data), sep=r'\s+')
tm.assert_frame_equal(actual, expected)
def test_skipfooter_with_decimal(self):
# see gh-6971
data = '1#2\n3#4'
expected = DataFrame({'a': [1.2, 3.4]})
result = self.read_csv(StringIO(data), names=['a'],
decimal='#')
tm.assert_frame_equal(result, expected)
# the stray footer line should not mess with the
# casting of the first t wo lines if we skip it
data = data + '\nFooter'
result = self.read_csv(StringIO(data), names=['a'],
decimal='#', skipfooter=1)
tm.assert_frame_equal(result, expected)
def test_encoding_non_utf8_multichar_sep(self):
# see gh-3404
expected = DataFrame({'a': [1], 'b': [2]})
for sep in ['::', '#####', '!!!', '123', '#1!c5',
'%!c!d', '@@#4:2', '_!pd#_']:
data = '1' + sep + '2'
for encoding in ['utf-16', 'utf-16-be', 'utf-16-le',
'utf-32', 'cp037']:
encoded_data = data.encode(encoding)
result = self.read_csv(BytesIO(encoded_data),
sep=sep, names=['a', 'b'],
encoding=encoding)
tm.assert_frame_equal(result, expected)
def test_multi_char_sep_quotes(self):
# see gh-13374
data = 'a,,b\n1,,a\n2,,"2,,b"'
msg = 'ignored when a multi-char delimiter is used'
with tm.assert_raises_regex(ParserError, msg):
self.read_csv(StringIO(data), sep=',,')
# We expect no match, so there should be an assertion
# error out of the inner context manager.
with pytest.raises(AssertionError):
with tm.assert_raises_regex(ParserError, msg):
self.read_csv(StringIO(data), sep=',,',
quoting=csv.QUOTE_NONE)
def test_skipfooter_bad_row(self):
# see gh-13879
# see gh-15910
msg = 'parsing errors in the skipped footer rows'
for data in ('a\n1\n"b"a',
'a,b,c\ncat,foo,bar\ndog,foo,"baz'):
with tm.assert_raises_regex(ParserError, msg):
self.read_csv(StringIO(data), skipfooter=1)
# We expect no match, so there should be an assertion
# error out of the inner context manager.
with pytest.raises(AssertionError):
with tm.assert_raises_regex(ParserError, msg):
self.read_csv(StringIO(data))
| bsd-3-clause |
andykimpe/chromium-test-npapi | chrome/browser/nacl_host/test/gdb_rsp.py | 99 | 2431 | # Copyright (c) 2012 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
# This file is based on gdb_rsp.py file from NaCl repository.
import re
import socket
import time
def RspChecksum(data):
checksum = 0
for char in data:
checksum = (checksum + ord(char)) % 0x100
return checksum
class GdbRspConnection(object):
def __init__(self, addr):
self._socket = self._Connect(addr)
def _Connect(self, addr):
# We have to poll because we do not know when sel_ldr has
# successfully done bind() on the TCP port. This is inherently
# unreliable.
# TODO(mseaborn): Add a more reliable connection mechanism to
# sel_ldr's debug stub.
timeout_in_seconds = 10
poll_time_in_seconds = 0.1
for i in xrange(int(timeout_in_seconds / poll_time_in_seconds)):
# On Mac OS X, we have to create a new socket FD for each retry.
sock = socket.socket()
try:
sock.connect(addr)
except socket.error:
# Retry after a delay.
time.sleep(poll_time_in_seconds)
else:
return sock
raise Exception('Could not connect to sel_ldr\'s debug stub in %i seconds'
% timeout_in_seconds)
def _GetReply(self):
reply = ''
while True:
data = self._socket.recv(1024)
if len(data) == 0:
raise AssertionError('EOF on socket reached with '
'incomplete reply message: %r' % reply)
reply += data
if '#' in data:
break
match = re.match('\+\$([^#]*)#([0-9a-fA-F]{2})$', reply)
if match is None:
raise AssertionError('Unexpected reply message: %r' % reply)
reply_body = match.group(1)
checksum = match.group(2)
expected_checksum = '%02x' % RspChecksum(reply_body)
if checksum != expected_checksum:
raise AssertionError('Bad RSP checksum: %r != %r' %
(checksum, expected_checksum))
# Send acknowledgement.
self._socket.send('+')
return reply_body
# Send an rsp message, but don't wait for or expect a reply.
def RspSendOnly(self, data):
msg = '$%s#%02x' % (data, RspChecksum(data))
return self._socket.send(msg)
def RspRequest(self, data):
self.RspSendOnly(data)
return self._GetReply()
def RspInterrupt(self):
self._socket.send('\x03')
return self._GetReply()
| bsd-3-clause |
icdishb/scikit-learn | examples/cluster/plot_kmeans_silhouette_analysis.py | 242 | 5885 | """
===============================================================================
Selecting the number of clusters with silhouette analysis on KMeans clustering
===============================================================================
Silhouette analysis can be used to study the separation distance between the
resulting clusters. The silhouette plot displays a measure of how close each
point in one cluster is to points in the neighboring clusters and thus provides
a way to assess parameters like number of clusters visually. This measure has a
range of [-1, 1].
Silhoette coefficients (as these values are referred to as) near +1 indicate
that the sample is far away from the neighboring clusters. A value of 0
indicates that the sample is on or very close to the decision boundary between
two neighboring clusters and negative values indicate that those samples might
have been assigned to the wrong cluster.
In this example the silhouette analysis is used to choose an optimal value for
``n_clusters``. The silhouette plot shows that the ``n_clusters`` value of 3, 5
and 6 are a bad pick for the given data due to the presence of clusters with
below average silhouette scores and also due to wide fluctuations in the size
of the silhouette plots. Silhouette analysis is more ambivalent in deciding
between 2 and 4.
Also from the thickness of the silhouette plot the cluster size can be
visualized. The silhouette plot for cluster 0 when ``n_clusters`` is equal to
2, is bigger in size owing to the grouping of the 3 sub clusters into one big
cluster. However when the ``n_clusters`` is equal to 4, all the plots are more
or less of similar thickness and hence are of similar sizes as can be also
verified from the labelled scatter plot on the right.
"""
from __future__ import print_function
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_samples, silhouette_score
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import numpy as np
print(__doc__)
# Generating the sample data from make_blobs
# This particular setting has one distict cluster and 3 clusters placed close
# together.
X, y = make_blobs(n_samples=500,
n_features=2,
centers=4,
cluster_std=1,
center_box=(-10.0, 10.0),
shuffle=True,
random_state=1) # For reproducibility
range_n_clusters = [2, 3, 4, 5, 6]
for n_clusters in range_n_clusters:
# Create a subplot with 1 row and 2 columns
fig, (ax1, ax2) = plt.subplots(1, 2)
fig.set_size_inches(18, 7)
# The 1st subplot is the silhouette plot
# The silhouette coefficient can range from -1, 1 but in this example all
# lie within [-0.1, 1]
ax1.set_xlim([-0.1, 1])
# The (n_clusters+1)*10 is for inserting blank space between silhouette
# plots of individual clusters, to demarcate them clearly.
ax1.set_ylim([0, len(X) + (n_clusters + 1) * 10])
# Initialize the clusterer with n_clusters value and a random generator
# seed of 10 for reproducibility.
clusterer = KMeans(n_clusters=n_clusters, random_state=10)
cluster_labels = clusterer.fit_predict(X)
# The silhouette_score gives the average value for all the samples.
# This gives a perspective into the density and separation of the formed
# clusters
silhouette_avg = silhouette_score(X, cluster_labels)
print("For n_clusters =", n_clusters,
"The average silhouette_score is :", silhouette_avg)
# Compute the silhouette scores for each sample
sample_silhouette_values = silhouette_samples(X, cluster_labels)
y_lower = 10
for i in range(n_clusters):
# Aggregate the silhouette scores for samples belonging to
# cluster i, and sort them
ith_cluster_silhouette_values = \
sample_silhouette_values[cluster_labels == i]
ith_cluster_silhouette_values.sort()
size_cluster_i = ith_cluster_silhouette_values.shape[0]
y_upper = y_lower + size_cluster_i
color = cm.spectral(float(i) / n_clusters)
ax1.fill_betweenx(np.arange(y_lower, y_upper),
0, ith_cluster_silhouette_values,
facecolor=color, edgecolor=color, alpha=0.7)
# Label the silhouette plots with their cluster numbers at the middle
ax1.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))
# Compute the new y_lower for next plot
y_lower = y_upper + 10 # 10 for the 0 samples
ax1.set_title("The silhouette plot for the various clusters.")
ax1.set_xlabel("The silhouette coefficient values")
ax1.set_ylabel("Cluster label")
# The vertical line for average silhoutte score of all the values
ax1.axvline(x=silhouette_avg, color="red", linestyle="--")
ax1.set_yticks([]) # Clear the yaxis labels / ticks
ax1.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])
# 2nd Plot showing the actual clusters formed
colors = cm.spectral(cluster_labels.astype(float) / n_clusters)
ax2.scatter(X[:, 0], X[:, 1], marker='.', s=30, lw=0, alpha=0.7,
c=colors)
# Labeling the clusters
centers = clusterer.cluster_centers_
# Draw white circles at cluster centers
ax2.scatter(centers[:, 0], centers[:, 1],
marker='o', c="white", alpha=1, s=200)
for i, c in enumerate(centers):
ax2.scatter(c[0], c[1], marker='$%d$' % i, alpha=1, s=50)
ax2.set_title("The visualization of the clustered data.")
ax2.set_xlabel("Feature space for the 1st feature")
ax2.set_ylabel("Feature space for the 2nd feature")
plt.suptitle(("Silhouette analysis for KMeans clustering on sample data "
"with n_clusters = %d" % n_clusters),
fontsize=14, fontweight='bold')
plt.show()
| bsd-3-clause |
trhongbinwang/data_science_journey | python/pandas/pandas_summary.py | 1 | 7928 | # -*- coding: utf-8 -*-
"""
Created on Wed Dec 7 15:55:37 2016
pandas summary
http://pandas.pydata.org/pandas-docs/stable/basics.html
can search this page to find howto
0 or ‘index’ for row-wise, 1 or ‘columns’ for column-wise
"""
import pickle
import pandas as pd
import numpy as np
# used in notebook
import matplotlib.pyplot as plt
%matplotlib inline
#.iloc() -- position index; .loc() -- label index.
# general info
df.head(), df.info()
# read excel data from a folder
from os import listdir
from os.path import isfile, join
# windows change from \ to /
mypath = 'C://Documents/data//'
fileNames = [f for f in listdir(mypath) if isfile(join(mypath, f))]
df_all = pd.DataFrame() # empty df
for fileName in fileNames:
fileName = join(mypath, fileName)
df = pd.read_excel(fileName)
print(df.shape)
df_all = df_all.append(df)
print(df_all.shape)
print(df_all.info())
# write into a excel file
writer = ExcelWriter('historical.xlsx')
df.to_excel(writer, 'fx')
writer.save()
# dump or load pickle
with open('historical.pkl', 'wb') as f:
pickle.dump(df_all, f)
df_loaded = pickle.load(open('historical.pkl', 'rb'))
# pd select columns
df_all = df_all[['level', 'name']]
# pd filtering
df = df[df['st'] != '-']
df = df[df['tr'] > 60]
# convert time from string to datetime
df['time']= pd.to_datetime(df['time'], infer_datetime_format=True)
# filtering the time
df_past = df[df['happen_time'] < datetime.datetime(2016,6,1,0,0,0)]
# pd sort by a column value
df = df.sort_values(by='st')
# format print
print('number of action = {0}'.format(len(df)))
# iterate dataframe
for i in range(1,len(df)):
if ((df.iloc[i]['name'] == df.iloc[i-1]['name']) # two index access maynot can change it
# generate new collumn from existing columns
df['tr'] = (df['st1'] - df['st']).apply(lambda x: x.total_seconds())
df['source'] = df['s1'] + ' / ' + df['s2']
# drop na and duplicates
df = df.drop_duplicates(['name', 'tv'])
df = df.dropna(subset = ['name'])
# convert pd into numpy array
pd.values
# another way to iterate pd row by row
for row in df.itertuples(index=False):
print(row) # row is a namedtuple
# group data using column
grouped = df.groupby('source')
for name, group in grouped:
# set value to an element in df
df.iloc[i, df.columns.get_loc('ro')] = 'de'
# drop columns from df
df = df.drop(['level', 'tr'], axis=1)
# pd concat or append
df = pd.concat([df, df_latest], axis=0)
# create pandas df from list of tuple, also can from a list or a dict
name_fre = [(name, len(group)) for name, group in grouped]
name_fre_df = pd.DataFrame(name_fre, columns=['name', 'Freq'])
# double condition selection
small_alarms = df[(name_fre_df['Frequency']>10) & (name_fre_df['Frequency']<100)]['name'].values.tolist()
# only select value from a list
df_large = df[df['name'].isin(large)]
# pd one hot encoding categorical data, better one use sklearn or write your own
hour_dummies = pd.get_dummies(ml_df['hour'],prefix='hour')
# apply func to a column
ip_head = ip_head.apply(lambda x: x.split('.')[0])
# add a column in pd
data['price'] = 0
# delete a column
del data['price']
# rename a column
data = data.rename(columns={'NAME':'PLANET'})
# The column names, as an Index object
print( df.columns )
# convert to list
list(df.columns)
# view pd's column in two styles
df.beer_style# 1. attribute style
df['beer_style'] # 2. dict style
# string operation and selection
boolean_mask = df.beer_style.str.contains('[A|a]merican')
df.beer_style[boolean_mask]
# Statistical Operations through Indexing
beer_ids = df.beer_id.value_counts(sort=True) # count frequency of each id
# iloc access
# row, column
df.iloc[[2,5,10],0:3]
# lambda funciton
lambda x: x= 0
# 3 steps
grouped = data.groupby(lambda x: x.year) #1. group
grouped.get_group(1997) #2. split
gr = df.groupby('beer_style') # gr is a groupby object
gr.agg('mean') # get some statistics from each group
# only a subset
review_columns = ['abv','review_overall','review_appearance',
'review_palate','review_taste']
gr[review_columns].agg('mean')
gr['review_aroma'].agg([np.mean, np.std, 'count']) # multiple aggregation
#
#Attributes and the raw ndarray(s)
# shape; columns and index
df.columns = [x.lower() for x in df.columns]
# Flexible binary operations
row = df.ix[1]
column = df['two']
df.sub(row, axis='columns')
df + df2
df.add(df2, fill_value=0)
df.gt(df2)
# Descriptive statistics; DataFrame: “index” (axis=0, default), “columns” (axis=1)
df.mean(0)
df.sum(0, skipna=False)
# normalize column
ts_stand = (df - df.mean()) / df.std()
# normalize each row
xs_stand = df.sub(df.mean(1), axis=0).div(df.std(1), axis=0)
# index of min and max
df1.idxmin(axis=0)
df1.idxmax(axis=1)
# Value counts (histogramming)
s = pd.Series(np.random.randint(0, 7, size=50))
s.value_counts()
# Row or Column-wise Function Application
df.apply(np.mean)
df.apply(np.mean, axis=1)
# can pass additional parameters to function
# Applying elementwise Python functions
# applymap() for df; map() for Series (column); func takes a single value and output a single value
f = lambda x: len(str(x))
df4['one'].map(f)
df4.applymap(f)
# iteration
for i in object:
# Series, value
# dataframe, column name
for col in df:
print(col)
# itertuples is a lot faster than iterrows
# itertuples return each row as a namedtuple
# a namedtuple is as row = (Index=0, a=1, b='a'). can be access as: row.a
# .dt for Series
s = pd.Series(pd.date_range('20130101 09:10:12', periods=4))
s.dt.day
s.dt.hour
s.dt.second
s[s.dt.day==2]
s.dt.strftime('%Y/%m/%d') # convert datatime to string
# pd.date_range to generate data range
# Vectorized string methods - Series; exclude missing/NA values automatically
s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'])
s.str.lower()
# clean up the columns; chaining because all method return a Series
df.columns = df.columns.str.strip().str.lower().str.replace(' ', '_')
# Sorting
#sort by index
unsorted_df.sort_index()
# sort by value
df1 = pd.DataFrame({'one':[2,1,1,1],'two':[1,3,2,4],'three':[5,4,3,2]})
df1[['one', 'two', 'three']].sort_values(by=['one','two'])
# smallest / largest values
s = pd.Series(np.random.permutation(10))
s.nsmallest(3)
df = pd.DataFrame({'a': [-2, -1, 1, 10, 8, 11, -1],
'b': list('abdceff')})
df.nlargest(3, 'a')
# series.nlargest
s = pd.Series(np.randam.rand(100))
s.largest(10)
# dtypes of each columns
dft.dtypes
#astype
dft = pd.DataFrame({'a': [1,2,3], 'b': [4,5,6], 'c': [7, 8, 9]})
dft[['a','b']] = dft[['a','b']].astype(np.uint8)
#pd.to_datetime()
#to_numeric()
df.apply(pd.to_datetime)
# Method chaining; since each method return a df.
def read(fp):
df = (pd.read_csv(fp)
.rename(columns=str.lower)
.drop('unnamed: 36', axis=1)
.pipe(extract_city_name)
.pipe(time_to_datetime, ['dep_time', 'arr_time', 'crs_arr_time', 'crs_dep_time'])
.assign(fl_date=lambda x: pd.to_datetime(x['fl_date']),
dest=lambda x: pd.Categorical(x['dest']),
origin=lambda x: pd.Categorical(x['origin']),
tail_num=lambda x: pd.Categorical(x['tail_num']),
unique_carrier=lambda x: pd.Categorical(x['unique_carrier']),
cancellation_code=lambda x: pd.Categorical(x['cancellation_code'])))
return df
# pipe your own function
>>> (df.pipe(h)
... .pipe(g, arg1=a)
... .pipe(f, arg2=b, arg3=c)
... )
| apache-2.0 |
Fireblend/scikit-learn | sklearn/neighbors/classification.py | 132 | 14388 | """Nearest Neighbor Classification"""
# Authors: Jake Vanderplas <[email protected]>
# Fabian Pedregosa <[email protected]>
# Alexandre Gramfort <[email protected]>
# Sparseness support by Lars Buitinck <[email protected]>
# Multi-output support by Arnaud Joly <[email protected]>
#
# License: BSD 3 clause (C) INRIA, University of Amsterdam
import numpy as np
from scipy import stats
from ..utils.extmath import weighted_mode
from .base import \
_check_weights, _get_weights, \
NeighborsBase, KNeighborsMixin,\
RadiusNeighborsMixin, SupervisedIntegerMixin
from ..base import ClassifierMixin
from ..utils import check_array
class KNeighborsClassifier(NeighborsBase, KNeighborsMixin,
SupervisedIntegerMixin, ClassifierMixin):
"""Classifier implementing the k-nearest neighbors vote.
Read more in the :ref:`User Guide <classification>`.
Parameters
----------
n_neighbors : int, optional (default = 5)
Number of neighbors to use by default for :meth:`k_neighbors` queries.
weights : str or callable
weight function used in prediction. Possible values:
- 'uniform' : uniform weights. All points in each neighborhood
are weighted equally.
- 'distance' : weight points by the inverse of their distance.
in this case, closer neighbors of a query point will have a
greater influence than neighbors which are further away.
- [callable] : a user-defined function which accepts an
array of distances, and returns an array of the same shape
containing the weights.
Uniform weights are used by default.
algorithm : {'auto', 'ball_tree', 'kd_tree', 'brute'}, optional
Algorithm used to compute the nearest neighbors:
- 'ball_tree' will use :class:`BallTree`
- 'kd_tree' will use :class:`KDTree`
- 'brute' will use a brute-force search.
- 'auto' will attempt to decide the most appropriate algorithm
based on the values passed to :meth:`fit` method.
Note: fitting on sparse input will override the setting of
this parameter, using brute force.
leaf_size : int, optional (default = 30)
Leaf size passed to BallTree or KDTree. This can affect the
speed of the construction and query, as well as the memory
required to store the tree. The optimal value depends on the
nature of the problem.
metric : string or DistanceMetric object (default = 'minkowski')
the distance metric to use for the tree. The default metric is
minkowski, and with p=2 is equivalent to the standard Euclidean
metric. See the documentation of the DistanceMetric class for a
list of available metrics.
p : integer, optional (default = 2)
Power parameter for the Minkowski metric. When p = 1, this is
equivalent to using manhattan_distance (l1), and euclidean_distance
(l2) for p = 2. For arbitrary p, minkowski_distance (l_p) is used.
metric_params : dict, optional (default = None)
Additional keyword arguments for the metric function.
n_jobs : int, optional (default = 1)
The number of parallel jobs to run for neighbors search.
If ``-1``, then the number of jobs is set to the number of CPU cores.
Doesn't affect :meth:`fit` method.
Examples
--------
>>> X = [[0], [1], [2], [3]]
>>> y = [0, 0, 1, 1]
>>> from sklearn.neighbors import KNeighborsClassifier
>>> neigh = KNeighborsClassifier(n_neighbors=3)
>>> neigh.fit(X, y) # doctest: +ELLIPSIS
KNeighborsClassifier(...)
>>> print(neigh.predict([[1.1]]))
[0]
>>> print(neigh.predict_proba([[0.9]]))
[[ 0.66666667 0.33333333]]
See also
--------
RadiusNeighborsClassifier
KNeighborsRegressor
RadiusNeighborsRegressor
NearestNeighbors
Notes
-----
See :ref:`Nearest Neighbors <neighbors>` in the online documentation
for a discussion of the choice of ``algorithm`` and ``leaf_size``.
.. warning::
Regarding the Nearest Neighbors algorithms, if it is found that two
neighbors, neighbor `k+1` and `k`, have identical distances but
but different labels, the results will depend on the ordering of the
training data.
http://en.wikipedia.org/wiki/K-nearest_neighbor_algorithm
"""
def __init__(self, n_neighbors=5,
weights='uniform', algorithm='auto', leaf_size=30,
p=2, metric='minkowski', metric_params=None, n_jobs=1,
**kwargs):
self._init_params(n_neighbors=n_neighbors,
algorithm=algorithm,
leaf_size=leaf_size, metric=metric, p=p,
metric_params=metric_params, n_jobs=n_jobs, **kwargs)
self.weights = _check_weights(weights)
def predict(self, X):
"""Predict the class labels for the provided data
Parameters
----------
X : array-like, shape (n_query, n_features), \
or (n_query, n_indexed) if metric == 'precomputed'
Test samples.
Returns
-------
y : array of shape [n_samples] or [n_samples, n_outputs]
Class labels for each data sample.
"""
X = check_array(X, accept_sparse='csr')
neigh_dist, neigh_ind = self.kneighbors(X)
classes_ = self.classes_
_y = self._y
if not self.outputs_2d_:
_y = self._y.reshape((-1, 1))
classes_ = [self.classes_]
n_outputs = len(classes_)
n_samples = X.shape[0]
weights = _get_weights(neigh_dist, self.weights)
y_pred = np.empty((n_samples, n_outputs), dtype=classes_[0].dtype)
for k, classes_k in enumerate(classes_):
if weights is None:
mode, _ = stats.mode(_y[neigh_ind, k], axis=1)
else:
mode, _ = weighted_mode(_y[neigh_ind, k], weights, axis=1)
mode = np.asarray(mode.ravel(), dtype=np.intp)
y_pred[:, k] = classes_k.take(mode)
if not self.outputs_2d_:
y_pred = y_pred.ravel()
return y_pred
def predict_proba(self, X):
"""Return probability estimates for the test data X.
Parameters
----------
X : array-like, shape (n_query, n_features), \
or (n_query, n_indexed) if metric == 'precomputed'
Test samples.
Returns
-------
p : array of shape = [n_samples, n_classes], or a list of n_outputs
of such arrays if n_outputs > 1.
The class probabilities of the input samples. Classes are ordered
by lexicographic order.
"""
X = check_array(X, accept_sparse='csr')
neigh_dist, neigh_ind = self.kneighbors(X)
classes_ = self.classes_
_y = self._y
if not self.outputs_2d_:
_y = self._y.reshape((-1, 1))
classes_ = [self.classes_]
n_samples = X.shape[0]
weights = _get_weights(neigh_dist, self.weights)
if weights is None:
weights = np.ones_like(neigh_ind)
all_rows = np.arange(X.shape[0])
probabilities = []
for k, classes_k in enumerate(classes_):
pred_labels = _y[:, k][neigh_ind]
proba_k = np.zeros((n_samples, classes_k.size))
# a simple ':' index doesn't work right
for i, idx in enumerate(pred_labels.T): # loop is O(n_neighbors)
proba_k[all_rows, idx] += weights[:, i]
# normalize 'votes' into real [0,1] probabilities
normalizer = proba_k.sum(axis=1)[:, np.newaxis]
normalizer[normalizer == 0.0] = 1.0
proba_k /= normalizer
probabilities.append(proba_k)
if not self.outputs_2d_:
probabilities = probabilities[0]
return probabilities
class RadiusNeighborsClassifier(NeighborsBase, RadiusNeighborsMixin,
SupervisedIntegerMixin, ClassifierMixin):
"""Classifier implementing a vote among neighbors within a given radius
Read more in the :ref:`User Guide <classification>`.
Parameters
----------
radius : float, optional (default = 1.0)
Range of parameter space to use by default for :meth`radius_neighbors`
queries.
weights : str or callable
weight function used in prediction. Possible values:
- 'uniform' : uniform weights. All points in each neighborhood
are weighted equally.
- 'distance' : weight points by the inverse of their distance.
in this case, closer neighbors of a query point will have a
greater influence than neighbors which are further away.
- [callable] : a user-defined function which accepts an
array of distances, and returns an array of the same shape
containing the weights.
Uniform weights are used by default.
algorithm : {'auto', 'ball_tree', 'kd_tree', 'brute'}, optional
Algorithm used to compute the nearest neighbors:
- 'ball_tree' will use :class:`BallTree`
- 'kd_tree' will use :class:`KDtree`
- 'brute' will use a brute-force search.
- 'auto' will attempt to decide the most appropriate algorithm
based on the values passed to :meth:`fit` method.
Note: fitting on sparse input will override the setting of
this parameter, using brute force.
leaf_size : int, optional (default = 30)
Leaf size passed to BallTree or KDTree. This can affect the
speed of the construction and query, as well as the memory
required to store the tree. The optimal value depends on the
nature of the problem.
metric : string or DistanceMetric object (default='minkowski')
the distance metric to use for the tree. The default metric is
minkowski, and with p=2 is equivalent to the standard Euclidean
metric. See the documentation of the DistanceMetric class for a
list of available metrics.
p : integer, optional (default = 2)
Power parameter for the Minkowski metric. When p = 1, this is
equivalent to using manhattan_distance (l1), and euclidean_distance
(l2) for p = 2. For arbitrary p, minkowski_distance (l_p) is used.
outlier_label : int, optional (default = None)
Label, which is given for outlier samples (samples with no
neighbors on given radius).
If set to None, ValueError is raised, when outlier is detected.
metric_params : dict, optional (default = None)
Additional keyword arguments for the metric function.
Examples
--------
>>> X = [[0], [1], [2], [3]]
>>> y = [0, 0, 1, 1]
>>> from sklearn.neighbors import RadiusNeighborsClassifier
>>> neigh = RadiusNeighborsClassifier(radius=1.0)
>>> neigh.fit(X, y) # doctest: +ELLIPSIS
RadiusNeighborsClassifier(...)
>>> print(neigh.predict([[1.5]]))
[0]
See also
--------
KNeighborsClassifier
RadiusNeighborsRegressor
KNeighborsRegressor
NearestNeighbors
Notes
-----
See :ref:`Nearest Neighbors <neighbors>` in the online documentation
for a discussion of the choice of ``algorithm`` and ``leaf_size``.
http://en.wikipedia.org/wiki/K-nearest_neighbor_algorithm
"""
def __init__(self, radius=1.0, weights='uniform',
algorithm='auto', leaf_size=30, p=2, metric='minkowski',
outlier_label=None, metric_params=None, **kwargs):
self._init_params(radius=radius,
algorithm=algorithm,
leaf_size=leaf_size,
metric=metric, p=p, metric_params=metric_params,
**kwargs)
self.weights = _check_weights(weights)
self.outlier_label = outlier_label
def predict(self, X):
"""Predict the class labels for the provided data
Parameters
----------
X : array-like, shape (n_query, n_features), \
or (n_query, n_indexed) if metric == 'precomputed'
Test samples.
Returns
-------
y : array of shape [n_samples] or [n_samples, n_outputs]
Class labels for each data sample.
"""
X = check_array(X, accept_sparse='csr')
n_samples = X.shape[0]
neigh_dist, neigh_ind = self.radius_neighbors(X)
inliers = [i for i, nind in enumerate(neigh_ind) if len(nind) != 0]
outliers = [i for i, nind in enumerate(neigh_ind) if len(nind) == 0]
classes_ = self.classes_
_y = self._y
if not self.outputs_2d_:
_y = self._y.reshape((-1, 1))
classes_ = [self.classes_]
n_outputs = len(classes_)
if self.outlier_label is not None:
neigh_dist[outliers] = 1e-6
elif outliers:
raise ValueError('No neighbors found for test samples %r, '
'you can try using larger radius, '
'give a label for outliers, '
'or consider removing them from your dataset.'
% outliers)
weights = _get_weights(neigh_dist, self.weights)
y_pred = np.empty((n_samples, n_outputs), dtype=classes_[0].dtype)
for k, classes_k in enumerate(classes_):
pred_labels = np.array([_y[ind, k] for ind in neigh_ind],
dtype=object)
if weights is None:
mode = np.array([stats.mode(pl)[0]
for pl in pred_labels[inliers]], dtype=np.int)
else:
mode = np.array([weighted_mode(pl, w)[0]
for (pl, w)
in zip(pred_labels[inliers], weights)],
dtype=np.int)
mode = mode.ravel()
y_pred[inliers, k] = classes_k.take(mode)
if outliers:
y_pred[outliers, :] = self.outlier_label
if not self.outputs_2d_:
y_pred = y_pred.ravel()
return y_pred
| bsd-3-clause |
KyleKing/My-Programming-Sketchbook | Python/BIOE232-Thermodynamics/HW19/BIOE232_HW19.py | 1 | 1394 | #' % HW19 - BIOE232
#' % Kyle King
#' % May 7, 2015
#' My First Python Script!
# For outputting nice HTML file/PDF
# import pweave
import pprint as pp
# All the essentials
import numpy as np # np.__version__
import matplotlib.pyplot as plt
import math
from decimal import *
from pylab import *
#' Question 1
# Declare varibales
Ka = 5.1E-7
pKa = -math.log10(Ka)
pH = np.linspace(0, 14, num=140)
ratio = 1/(1 + pow(10, (pKa - pH)))
# Print out constants
pp.pprint(['Ka = ', Ka])
pp.pprint(['pKa = ', pKa])
# Plot function
plot(pH, ratio)
title('HW19: Q1 The ratio of C_b / C_total versus pH')
xlabel('pH')
ylabel('Ratio of C_b / C_total')
grid(True)
# show()
#' Question 2
# Declare varibales
pKa1, pKa2 = 6.3, 10.8
pH = np.linspace(0, 14, num=140)
Dratio1 = 1/(1 + pow(10, (pKa1 - pH)))
Dratio2 = 1/(1 + pow(10, (pKa2 - pH)))
# Print out constants
# pp.pprint(['Dratio1 = ', Dratio1])
# pp.pprint(['Dratio2 = ', Dratio2])
# Plot function
fig = plt.figure()
ax1 = fig.add_axes([0.1, 0.1, 0.8, 0.7])
l1, l2 = ax1.plot(pH, Dratio1, '-*', pH, Dratio2)
fig.legend((l1, l2), ('Ajmalicine', 'Serpentine'), 'upper right')
title('HW19: Q2 The ratio of D_overall / D versus pH')
xlabel('pH')
ylabel('Ratio of D_overall / D')
grid(True)
# plt.show()
#' Question 3
pKa, pHv, pHc = 6.3, 3, 7
conc = (1+pow(10, pKa - pHv)) / (1+pow(10, pKa - pHc))
pp.pprint(['Concentration Ability = ', conc])
| mit |
mynlp/ccg2lambda | scripts/evaluate.py | 1 | 12193 | #!/usr/bin/python3
# -*- coding: utf-8 -*-
#
# Copyright 2015 Pascual Martinez-Gomez
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import print_function
import argparse
import codecs
from collections import Counter
import logging
from lxml import etree
import os
import sys
import textwrap
from tqdm import tqdm
from pandas_ml import ConfusionMatrix
from visualization_tools import convert_doc_to_mathml
from visualization_tools import wrap_mathml_in_html
def load_files(proof_fnames):
"""
From a list of XML filenames that contain a <proof> node,
it returns a list of lxml root nodes.
"""
roots = []
parser = etree.XMLParser(remove_blank_text=True)
for fname in proof_fnames:
docs = etree.parse(fname, parser)
roots.append(docs)
return roots
possible_inference_results = set(['yes', 'no', 'unknown'])
def select_result(inference_results):
"""
inference_results is a list with elements {'yes', 'no', 'unknown'}.
"""
if not inference_results:
return 'unknown'
for r in inference_results:
assert r in possible_inference_results, '{0} not in {1}'.format(r, possible_inference_results)
if r != 'unknown':
return r
return 'unknown'
def get_sys_labels(roots):
labels = dict()
for root in roots:
for doc in root.xpath('./document'):
problem_id = doc.get('pair_id', None)
if problem_id is not None and labels.get(problem_id, None) not in ['yes', 'no']:
inference_results = doc.xpath('./proof/@inference_result')
labels[problem_id] = select_result(inference_results)
return labels
def get_gold_labels(roots):
labels = dict()
for root in roots:
for doc in root.xpath('./document'):
problem_id = doc.get('pair_id', None)
rte_label = doc.get('rte_label', None)
if problem_id is not None and rte_label is not None:
if problem_id in labels and labels[problem_id] != rte_label:
logging.warning(
'problem_id {0} with different rte_label: {1} vs {2}'.format(
problem_id, labels[problem_id], rte_label))
else:
labels[problem_id] = rte_label
return labels
def print_accuracy(gold_labels, sys_labels):
if len(gold_labels) != len(sys_labels):
logging.warning(
'In computing accuracy, the number of gold and system labels differs: g{0} vs s{1}.'.format(
len(gold_labels), len(sys_labels)))
hits = 0
for prob_id, gold_label in gold_labels.items():
if sys_labels.get(prob_id, 'unknown') == gold_label:
hits += 1
accuracy = float(hits) / len(gold_labels)
print('Accuracy: {0:.4f} ({1}/{2})'.format(accuracy, hits, len(gold_labels)))
def print_label_distribution(labels, title=''):
c = Counter(labels.values())
print('Label Distribution {0}: {1}'.format(title.rjust(5), c))
def print_confusion_matrix(gold_id_labels, sys_id_labels):
gold_ids = gold_id_labels.keys()
gold_labels = [gold_id_labels[i] for i in gold_ids]
sys_labels = [sys_id_labels.get(i, 'unknown') for i in gold_ids]
c = ConfusionMatrix(gold_labels, sys_labels)
print('Confusion matrix:\n{0}'.format(c))
true_positives = c.get('yes', 'yes') + c.get('no', 'no')
true_negatives = c.get('unknown', 'unknown')
false_positives = c.get('unknown', 'yes') + c.get('unknown', 'no') + c.get('no', 'yes') + c.get('yes', 'no')
false_negatives = c.get('yes', 'unknown') + c.get('no', 'unknown')
print('Precision : {0:.4f}'.format(
float(true_positives) / (true_positives + false_positives)))
print('Recall : {0:.4f}'.format(
float(true_positives) / (true_positives + false_negatives)))
print('True positives : {0}'.format(true_positives))
print('True negatives : {0}'.format(true_negatives))
print('False positives: {0}'.format(false_positives))
print('False negatives: {0}'.format(false_negatives))
def print_num_syntactic_errors(roots):
"""
Syntactic parse errors are likely to be signaled by sentence XML nodes
for which there is no 'tokens' node (failure of syntactic parser
earlier in the pipeline).
"""
syn_errors = [s for root in roots for s in root.xpath(
'./document/sentences/sentence') if not s.xpath('./tokens')]
print('Syntactic parse errors: {0}'.format(len(syn_errors)))
def print_num_semantic_errors(roots):
sem_errors = [se for root in roots for se in root.xpath(
'./document/sentences/sentence/semantics[@status="failed"]')]
sem_syn_errors = [se for se in sem_errors if not se.getparent().xpath('./tokens')]
print('Semantic parse errors: {0} (from which {1} are syntactic errors)'.format(
len(sem_errors), len(sem_syn_errors)))
def print_proof_status_stats(roots):
statuses = [s for root in roots for s in root.xpath('./document/proof/@status')]
c = Counter(statuses)
print('Proof status distribution: {0}'.format(c))
def get_problems(roots, error='false_positives'):
if error == 'false_positives':
cond = '@rte_label = "unknown" and ./proof/@inference_result != "unknown"'
elif error == 'false_negatives':
cond = '@rte_label != "unknown" and ./proof/@inference_result = "unknown"'
elif error == 'true_positives':
cond = '@rte_label != "unknown" and ./proof/@inference_result = @rte_label'
elif error == 'true_negatives':
cond = '@rte_label = "unknown" and ./proof/@inference_result = @rte_label'
else:
return [p for root in roots for p in root.xpath('./document')]
problems = [p for root in roots for p in root.xpath('./document[{0}]'.format(cond))]
return problems
def get_open_formula(doc):
f = doc.xpath('./proof/theorems/theorem/failure_log[1]/@open_formula')
if len(f) == 0:
return 'no'
return f[0]
def get_type_error(doc):
f = doc.xpath('./proof/theorems/theorem/failure_log[1]/@type_error')
if len(f) == 0:
return 'no'
return f[0]
def print_stats_for(roots, error='false_positives'):
problems = get_problems(roots, error)
open_formulas = [get_open_formula(p) for p in problems]
type_errors = [get_type_error(p) for p in problems]
print('{0}: {1}'.format(error, len(problems)))
ct = Counter(type_errors)
print(' Type error distribution: {0}'.format(ct))
co = Counter(open_formulas)
print(' Open formula distribution: {0}'.format(co))
def make_html_header():
return (
"<!doctype html>\n"
"<html lang='en'>\n"
"<head>\n"
" <meta charset='UTF-8'>\n"
" <title>Evaluation results</title>\n"
" <style>\n"
" body {\n"
" font-size: 1.5em;\n"
" }\n"
" </style>\n"
"</head>\n"
"<body>\n"
"<table border='1'>\n"
"<tr>\n"
" <td>sick problem</td>\n"
" <td>gold answer</td>\n"
" <td>system answer</td>\n"
" <td>proving time</td>\n"
"</tr>\n")
def make_html_tail():
return '</table>\n</body>\n</html>'
def print_html_problem(doc, dir_name):
prob_id = doc.get('pair_id', '00000')
prob_html_fname = dir_name + '/' + prob_id + '.html'
if prob_id == '00000':
logging.warning(
'RTE problem ID unspecified. Overwriting ' + prob_html_fname)
coq_scripts = doc.xpath('./proof/theorems/theorem/coq_script/text()')
mathml_str = convert_doc_to_mathml(doc)
html_str = wrap_mathml_in_html(mathml_str)
with codecs.open(prob_html_fname, 'w', 'utf-8') as fout:
fout.write(html_str)
return
red_color="rgb(255,0,0)"
green_color="rgb(0,255,0)"
white_color="rgb(255,255,255)"
gray_color="rgb(136,136,136)"
def print_html_problems(problems, fname_base, dir_name):
html_head = make_html_header()
with codecs.open('{0}/{1}.html'.format(dir_name, fname_base), 'w', 'utf-8') as fout:
fout.write(html_head)
for p in tqdm(problems):
print_html_problem(p, dir_name)
gold_label = p.get('rte_label', 'None')
sys_label = p.xpath('./proof/@inference_result')[0]
if gold_label == 'unknown' and sys_label != 'unknown':
color = red_color # false positive
elif gold_label == sys_label:
color = green_color # true positive and true negative.
elif gold_label != 'unknown' and sys_label == 'unknown':
color = gray_color # false negative
else:
color = white_color
prob_id = p.get('pair_id', '00000')
prob_html_fname = prob_id + '.html'
proving_time = -1.0
html_str = (
'<tr>\n'
' <td><a style="background-color:{0};" href="{1}">{2}</a></td>\n'
' <td>{3}</td>\n'
' <td>{4}</td>\n'
' <td>{5}s</td>\n'
'</tr>\n').format(
color, prob_html_fname, prob_id, gold_label, sys_label, proving_time)
fout.write(html_str)
html_tail = make_html_tail()
fout.write(html_tail)
def print_html(roots, fname_base='main', dir_name='results'):
print('Creating HTML graphical output. Please be patient...')
problems = get_problems(roots, '')
print_html_problems(problems, fname_base + '_all', dir_name)
print('HTML graphical output written to {0}/{1}_all.html'.format(dir_name, fname_base))
def main(args = None):
DESCRIPTION=textwrap.dedent("""\
The XML input file proof should contain the gold and automatic inference results.
""")
parser = argparse.ArgumentParser(
formatter_class=argparse.RawDescriptionHelpFormatter,
description=DESCRIPTION)
parser.add_argument("proofs", nargs='+',
help="XML input filename(s) with proof results.")
parser.add_argument("--dir_name", nargs='?', type=str, default='',
help="Directory name where evaluation results will be stored.")
args = parser.parse_args()
logging.basicConfig(level=logging.WARNING)
if any(not os.path.exists(p) for p in args.proofs):
print('One of the files does not exists: {0}'.format(args.proofs),
file=sys.stderr)
parser.print_help(file=sys.stderr)
sys.exit(1)
proof_fnames = args.proofs
roots = load_files(proof_fnames)
gold_labels = get_gold_labels(roots)
sys_labels = get_sys_labels(roots)
print('Number of problems processed: {0}'.format(len(sys_labels)))
if gold_labels:
print_accuracy(gold_labels, sys_labels)
print_confusion_matrix(gold_labels, sys_labels)
print_label_distribution(gold_labels, 'gold')
print_label_distribution(sys_labels, 'sys')
print_stats_for(roots, 'false_positives')
print_stats_for(roots, 'false_negatives')
print_stats_for(roots, 'true_positives')
print_stats_for(roots, 'true_negatives')
else:
logging.warning('No gold RTE labels provided.')
print_num_syntactic_errors(roots)
print_num_semantic_errors(roots)
print_proof_status_stats(roots)
if args.dir_name:
if not os.path.exists(args.dir_name):
os.makedirs(args.dir_name)
print_html(roots, 'main', args.dir_name)
# fps = get_problems(roots, 'false_negatives')
# for fp in fps:
# print('{0} {1} {2}'.format(
# fp.get('pair_id'),
# fp.get('rte_label'),
# fp.xpath('./proof/@inference_result')[0]))
if __name__ == '__main__':
main()
| apache-2.0 |
daodaoliang/bokeh | examples/charts/file/scatter.py | 37 | 1607 |
from collections import OrderedDict
import pandas as pd
from bokeh.charts import Scatter, output_file, show, vplot
from bokeh.sampledata.iris import flowers
setosa = flowers[(flowers.species == "setosa")][["petal_length", "petal_width"]]
versicolor = flowers[(flowers.species == "versicolor")][["petal_length", "petal_width"]]
virginica = flowers[(flowers.species == "virginica")][["petal_length", "petal_width"]]
xyvalues = OrderedDict([("setosa", setosa.values), ("versicolor", versicolor.values), ("virginica", virginica.values)])
scatter1 = Scatter(xyvalues, title="iris dataset, dict_input", xlabel="petal_length",
ylabel="petal_width", legend='top_left', marker="triangle")
groupped_df = flowers[["petal_length", "petal_width", "species"]].groupby("species")
scatter2 = Scatter(groupped_df, title="iris dataset, dict_input", xlabel="petal_length",
ylabel="petal_width", legend='top_left')
pdict = OrderedDict()
for i in groupped_df.groups.keys():
labels = groupped_df.get_group(i).columns
xname = labels[0]
yname = labels[1]
x = getattr(groupped_df.get_group(i), xname)
y = getattr(groupped_df.get_group(i), yname)
pdict[i] = list(zip(x, y))
df = pd.DataFrame(pdict)
scatter3 = Scatter(
df, title="iris dataset, dict_input",
xlabel="petal_length", ylabel="petal_width", legend='top_left')
scatter4 = Scatter(
list(xyvalues.values()), title="iris dataset, dict_input",
xlabel="petal_length", ylabel="petal_width", legend='top_left')
output_file("scatter.html")
show(vplot(scatter1, scatter2, scatter3, scatter4))
| bsd-3-clause |
smjhnits/Praktikum_TU_D_16-17 | Anfängerpraktikum/Protokolle/V355_Gekoppelte_Schwingungen/LaTex-Dateien/Messungb_Plot1.py | 1 | 1554 | import numpy as np
from scipy.stats import sem
from uncertainties import ufloat
import uncertainties.unumpy as unp
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
L = 32.51 * 10 ** (-3)
C = 0.801 * 10 ** (-9)
Csp = 0.037 * 10 ** (-9)
R = 48
Nü_negativ = np.array([33.16, 33.66, 34.25, 35.12, 36.08, 37.60, 40.28, 47.33]) * 10 ** (3)
Nü_positiv = np.array([30.77, 30.79, 30.80, 30.81, 30.82, 30.83, 30.84, 30.85]) * 10 ** (3)
Kopplungskapazitäten = np.array([9.99, 8, 6.47, 5.02, 4.00, 3.00, 2.03, 1.01]) * 10 ** (-9)
C_K_Error = np.array([ufloat(n, 0.003*n) for n in Kopplungskapazitäten])
nu_m_theo = np.array([1 / ( 2 * np.pi * unp.sqrt( L * ( (1/C + 2/n)**(-1) + Csp) ) ) for n in C_K_Error])
nu_p_theo = 1 / ( 2 * np.pi * np.sqrt( L * ( C + Csp) ) )
nu_p_theo1 = np.array([nu_p_theo, nu_p_theo, nu_p_theo, nu_p_theo, nu_p_theo, nu_p_theo, nu_p_theo, nu_p_theo ])
nu_m_theo1 = np.array([unp.nominal_values(n) for n in nu_m_theo])
plt.plot(Kopplungskapazitäten, Nü_negativ*10**(-3), 'bx', label = r'Messung 3.2: $\nu_{-}$')
plt.plot(Kopplungskapazitäten, nu_m_theo1*10**(-3), 'rx', label = r'Theoriewerte: $\nu_{-}$')
plt.plot(Kopplungskapazitäten, Nü_positiv*10**(-3), 'mx', label = r'Messung 3.2: $\nu_{+}$')
plt.plot(Kopplungskapazitäten, nu_p_theo1*10**(-3), 'yx', label = r'Theoriewerte: $\nu_{+}$')
plt.xlabel(r'$Kopplungskapazität \,\, C_k \,\, in \,\, \mathrm{F}$')
plt.ylabel(r'$Frequenzen \,\, \nu \,\, in \,\, \mathrm{kHz}$')
plt.legend(loc = 'best')
#plt.show()
plt.savefig('Messungb_Plot1.pdf')
| mit |
daniaki/pyPPI | pyppi/data_mining/uniprot.py | 1 | 16331 | """
Purpose: Wrapper methods for accessing uniprot records using biopython. See
http://biopython.org/DIST/docs/api/Bio.SwissProt.Record-class.html for more
information about how biopython stores records.
"""
import time
import logging
import pandas as pd
from Bio import SwissProt
from Bio import ExPASy
from bioservices import UniProt as UniProtMapper
from urllib.error import HTTPError
from enum import Enum
from joblib import delayed, Parallel
from ..base.utilities import chunk_list
from ..base.io import uniprot_sprot, uniprot_trembl
from ..database.models import Protein
from ..database.validators import (
validate_go_annotations,
validate_boolean, validate_pfam_annotations,
validate_function, validate_interpro_annotations,
validate_keywords
)
UNIPROT_ORD_KEY = dict(P=0, Q=1, O=2)
logger = logging.getLogger("pyppi")
http_error_msg = "Unrecoverable HTTPError downloading record for {}."
ERRORS_TO_RETRY = ('503', '504', '408')
# --------------------------------------------------------------------------- #
#
# Biopython/SwissProt Download Utilities
#
# --------------------------------------------------------------------------- #
def download_record(accession, verbose=False, wait=5,
retries=3, taxon_id=9606):
"""Download a record for a UniProt accession via the UniProt API.
The call will retry upon timeout up to the number specified by `retries`.
Parameters
----------
accession : str
UniProt accession.
verbose : bool, optional
If True, log informational and warning messages to the console.
wait : int, optional
Seconds to wait before retrying download.
retries : int, optional
Number of times to retry the download if the server returns
errors `503`, `504` or `408`.
taxon_id : int, optional
The taxonomy id to download the accession for. No record is returned
if the downloaded record does not match this id.
Returns
-------
:class:`Bio.SwissProt.Record`
A UniProt record instance.
"""
record = None
success = False
try:
handle = ExPASy.get_sprot_raw(accession)
record = SwissProt.read(handle)
success = True
except HTTPError as httperr:
if httperr.code in ERRORS_TO_RETRY:
if verbose:
logger.exception(http_error_msg.format(accession))
logger.info("Re-attempting to download.")
for i in range(retries):
logger.info("Attempt %s/%s." % (i + 1, retries))
time.sleep(wait)
try:
handle = ExPASy.get_sprot_raw(accession)
record = SwissProt.read(handle)
success = True
except HTTPError:
pass
else:
if verbose:
logger.exception(http_error_msg.format(accession))
except ValueError:
if verbose:
logger.exception("No record found for '{}'.".format(accession))
record = None
success = False
if not success:
if verbose:
logger.warning(
"Failed to download record for '{}'".format(accession)
)
record = None
if (not taxon_id is None) and (not record is None) and \
int(record.taxonomy_id[0]) != taxon_id:
if verbose:
logger.warning(
"Taxonomy IDs do not match for record {}. "
"Expected '{}' but found '{}'.".format(
accession, taxon_id, int(record.taxonomy_id[0])
)
)
record = None
return record
def download_records(accessions, verbose=False, wait=5,
retries=3, taxon_id=9606):
"""Download records for each UniProt accession via the UniProt API.
The call will retry upon timeout up to the number specified by `retries`.
Parameters
----------
accession : str
UniProt accession.
verbose : bool, optional
If True, log informational and warning messages to the console.
wait : int, optional
Seconds to wait before retrying download.
retries : int, optional
Number of times to retry the download if the server returns
errors `503`, `504` or `408`.
taxon_id : int, optional
The taxonomy id to download the accession for. No record is returned
if the downloaded record does not match this id.
Returns
-------
`list`
A list of :class:`Bio.SwissProt.Record` record instances.
"""
return [
download_record(a, verbose, wait, retries, taxon_id)
for a in accessions
]
def parallel_download(accessions, backend="multiprocessing",
verbose=False, n_jobs=1, wait=5,
retries=3, taxon_id=9606):
"""Parallel download records for UniProt accessions via the UniProt API.
The call will retry upon timeout up to the number specified by `retries`.
Parameters
----------
accession : str
UniProt accession.
verbose : bool, optional
If True, log informational and warning messages to the console.
wait : int, optional
Seconds to wait before retrying download.
retries : int, optional
Number of times to retry the download if the server returns
errors `503`, `504` or `408`.
taxon_id : int, optional
The taxonomy id to download the accession for. No record is returned
if the downloaded record does not match this id.
backend : str
A supported `Joblib` backend. Can be either 'multiprocessing' or
'threading'.
Returns
-------
`list`
A list of :class:`Bio.SwissProt.Record` record instances.
"""
# Warning: Setting backend to multiprocessing may cause strange errors.
# This is most likely due to this function not being run in a
# protected main loop.
accession_chunks = chunk_list(accessions, n=n_jobs)
records = Parallel(backend=backend, verbose=verbose, n_jobs=n_jobs)(
delayed(download_records)(chunk, verbose, wait, retries, taxon_id)
for chunk in list(accession_chunks)
)
return [r for sublist in records for r in sublist]
def serialise_record(record):
"""
Serialises the fields in a record that can then used to instantiate
a :class:`Protein` instance.
Parameters
----------
record : :class:`Bio.SwissProt.Record`
Record to serialise
Returns
-------
`dict`
Serialises the fields in a record that can then used to instantiate
a :class:`Protein` instance.
"""
if record is None:
return None
else:
uniprot_id = recent_accession(record)
taxon_id = taxonid(record)
gene_id = gene_name(record)
go_mf = go_terms(record, ont="mf")
go_bp = go_terms(record, ont="bp")
go_cc = go_terms(record, ont="cc")
interpro = interpro_terms(record)
pfam = pfam_terms(record)
reviewed = True if review_status(record) == 'Reviewed' else False
keywords_ = keywords(record)
function_ = function(record)
last_update_ = last_update(record)
last_release_ = last_release(record)
data = dict(
uniprot_id=uniprot_id, taxon_id=taxon_id, reviewed=reviewed,
gene_id=gene_id, go_mf=go_mf, go_bp=go_bp, go_cc=go_cc,
interpro=interpro, pfam=pfam, keywords=keywords_,
function=function_, last_update=last_update_,
last_release=last_release_
)
return data
def parse_record_into_protein(record, verbose=False):
"""
Instantiate a :class:`Protein` instance from a
:class:`Bio.SwissProt.Record` instance. It will not be saved to the
global session or database.
Parameters
----------
record : :class:`Bio.SwissProt.Record`
Record to turn into a :class:`Protein` instance.
verbose : bool, optional
If True, log informational and warning messages to the console.
Returns
-------
:class:`Protein`
Instantiated protein instance that has not been saved.
"""
if record is None:
return None
try:
constuctor_args = serialise_record(record)
entry = Protein(**constuctor_args)
return entry
except:
if verbose:
logger.exception("An error occured when trying to parse record.")
raise
# --------------------------------------------------------------------------- #
#
# Biopython/SwissProt Record Parsing
#
# --------------------------------------------------------------------------- #
def batch_map(accessions, fr='ACC+ID', allow_download=False, cache=False,
session=None, keep_unreviewed=True, match_taxon_id=9606,
verbose=False):
"""
Map a list of accessions using the UniProt batch mapping service.
Parameters
----------
accessions : list
List of accessions.
fr : str, optional
Database to map from. See :class:`bioservices.UniProt`.
keep_unreviewed : bool, optional
If True, keep the unreviewed accession in mapping.
allow_download : bool, optional
If True, will download records that are missing for any accession
in `accessions`.
cache : bool, optional
If True, `bioservices` cache will be used by
:class:`bioservices.UniProt`. Set to `False` to use the most up-to-date
mappings.
session : `scoped_session`, optional
Session instance to save protein instances to if `allow_download`
is True.
match_taxon_id : int, optional
Ignores mappings to or from proteins that do not match this id.
verbose : bool, optional
Log info/warning/error messages to the console.
Returns
-------
`dict`
A dictionary of mappings from UniProt accessions to the most
up-to-date UniProt accessions. Dictionary values are lists.
"""
uniprot_mapper = UniProtMapper(cache=cache)
filtered_mapping = {}
mapping = uniprot_mapper.mapping(fr=fr, to='ACC', query=accessions)
# No data was downloaded, try again a few times.
if mapping == {}:
for i in range(0, 4):
mapping = uniprot_mapper.mapping(
fr=fr, to='ACC', query=accessions
)
if mapping:
break
else:
if verbose:
logger.warning(
"Could not download map from uniprot server. "
"Attempt {}/5. Re-attempt in 3 seconds.".format(i + 2)
)
time.sleep(3)
if mapping == {}:
raise ValueError("Could not download map from uniprot server.")
for fr, to in mapping.items():
# Make sure any new accessions are in the database
invalid_to = []
for accession in to:
# Check to see if a protein macthing accession and the
# taxon id exists.
entry = Protein.get_by_uniprot_id(accession)
if entry is not None:
if (match_taxon_id is not None) and entry.taxon_id != match_taxon_id:
invalid_to.append(accession)
else:
if allow_download:
if verbose:
logger.info(
"Mapping to {}, but entry not found in database. "
"Attempting download.".format(accession)
)
record = download_record(
accession, verbose=True, taxon_id=match_taxon_id
)
protein = parse_record_into_protein(record)
if protein is not None:
protein.save(session, commit=True)
else:
if verbose:
logger.info(
"No valid record for {} was found".format(
accession)
)
invalid_to.append(accession)
else:
invalid_to.append(accession)
to = [a for a in to if a not in invalid_to]
status = [Protein.get_by_uniprot_id(a).reviewed for a in to]
reviewed = [a for (a, s) in zip(to, status) if s is True]
unreviewed = [a for (a, s) in zip(to, status) if s is False]
targets = reviewed
if keep_unreviewed:
targets += unreviewed
targets = list(set(targets))
if not (match_taxon_id is None):
taxon_ids = [
Protein.get_by_uniprot_id(a).taxon_id for a in targets
]
targets = [
t for (t, taxon_id) in zip(targets, taxon_ids)
if match_taxon_id == taxon_id
]
filtered_mapping[fr] = list(sorted(targets))
return filtered_mapping
def __xrefs(db_name, record):
result = []
for xref in record.cross_references:
extdb = xref[0]
if extdb == db_name:
result.append(xref[1:])
return result
def recent_accession(record):
if not record:
return None
return record.accessions[0]
def taxonid(record):
if not record:
return None
data = record.taxonomy_id[0]
return int(data)
def review_status(record):
if not record:
return None
return record.data_class
def gene_name(record):
if not record:
return None
try:
data = record.gene_name.split(';')[0].split('=')[-1].split(' ')[0]
except (KeyError, AssertionError, Exception):
data = None
if not data:
return None
return data
def go_terms(record, ont):
if not record:
return None
data = __xrefs("GO", record)
ids = list(map(lambda x: x[0], data))
names = list(map(lambda x: x[1], data))
if ont == 'mf':
ids = [i for (i, n) in zip(ids, names) if n[0] == 'F']
elif ont == 'bp':
ids = [i for (i, n) in zip(ids, names) if n[0] == 'P']
elif ont == 'cc':
ids = [i for (i, n) in zip(ids, names) if n[0] == 'C']
else:
pass
return ids
def pfam_terms(record):
if not record:
return None
data = __xrefs("Pfam", record)
return list(map(lambda x: x[0], data))
def interpro_terms(record):
if not record:
return None
data = __xrefs("InterPro", record)
return list(map(lambda x: x[0], data))
def keywords(record):
if not record:
return None
data = record.keywords
return data
def organism_code(record):
if not record:
return None
data = record.entry_name
data = data.split('_')[1]
return data
def entry_name(record):
if not record:
return None
return record.entry_name
def last_release(record):
if not record:
return None
return int(record.annotation_update[1])
def last_update(record):
if not record:
return None
return record.annotation_update[0]
def synonyms(record):
if not record:
return None
try:
data = record.gene_name.split(';')[1].split('=')[1].split(
', ').split(' ')[0]
except (KeyError, AssertionError, Exception):
data = None
return data
def function(r):
if r is None:
return None
elif not r.comments:
return None
else:
function = [x for x in r.comments if 'FUNCTION:' in x]
if not function:
return None
else:
return function[0].replace("FUNCTION: ", '')
| mit |
HesselTjeerdsma/Cyber-Physical-Pacman-Game | Algor/flask/lib/python2.7/site-packages/scipy/misc/common.py | 17 | 6104 | """
Functions which are common and require SciPy Base and Level 1 SciPy
(special, linalg)
"""
from __future__ import division, print_function, absolute_import
import numpy as np
from numpy import arange, newaxis, hstack, product, array, fromstring
__all__ = ['central_diff_weights', 'derivative', 'lena', 'ascent', 'face']
def central_diff_weights(Np, ndiv=1):
"""
Return weights for an Np-point central derivative.
Assumes equally-spaced function points.
If weights are in the vector w, then
derivative is w[0] * f(x-ho*dx) + ... + w[-1] * f(x+h0*dx)
Parameters
----------
Np : int
Number of points for the central derivative.
ndiv : int, optional
Number of divisions. Default is 1.
Notes
-----
Can be inaccurate for large number of points.
"""
if Np < ndiv + 1:
raise ValueError("Number of points must be at least the derivative order + 1.")
if Np % 2 == 0:
raise ValueError("The number of points must be odd.")
from scipy import linalg
ho = Np >> 1
x = arange(-ho,ho+1.0)
x = x[:,newaxis]
X = x**0.0
for k in range(1,Np):
X = hstack([X,x**k])
w = product(arange(1,ndiv+1),axis=0)*linalg.inv(X)[ndiv]
return w
def derivative(func, x0, dx=1.0, n=1, args=(), order=3):
"""
Find the n-th derivative of a function at a point.
Given a function, use a central difference formula with spacing `dx` to
compute the `n`-th derivative at `x0`.
Parameters
----------
func : function
Input function.
x0 : float
The point at which `n`-th derivative is found.
dx : float, optional
Spacing.
n : int, optional
Order of the derivative. Default is 1.
args : tuple, optional
Arguments
order : int, optional
Number of points to use, must be odd.
Notes
-----
Decreasing the step size too small can result in round-off error.
Examples
--------
>>> from scipy.misc import derivative
>>> def f(x):
... return x**3 + x**2
>>> derivative(f, 1.0, dx=1e-6)
4.9999999999217337
"""
if order < n + 1:
raise ValueError("'order' (the number of points used to compute the derivative), "
"must be at least the derivative order 'n' + 1.")
if order % 2 == 0:
raise ValueError("'order' (the number of points used to compute the derivative) "
"must be odd.")
# pre-computed for n=1 and 2 and low-order for speed.
if n == 1:
if order == 3:
weights = array([-1,0,1])/2.0
elif order == 5:
weights = array([1,-8,0,8,-1])/12.0
elif order == 7:
weights = array([-1,9,-45,0,45,-9,1])/60.0
elif order == 9:
weights = array([3,-32,168,-672,0,672,-168,32,-3])/840.0
else:
weights = central_diff_weights(order,1)
elif n == 2:
if order == 3:
weights = array([1,-2.0,1])
elif order == 5:
weights = array([-1,16,-30,16,-1])/12.0
elif order == 7:
weights = array([2,-27,270,-490,270,-27,2])/180.0
elif order == 9:
weights = array([-9,128,-1008,8064,-14350,8064,-1008,128,-9])/5040.0
else:
weights = central_diff_weights(order,2)
else:
weights = central_diff_weights(order, n)
val = 0.0
ho = order >> 1
for k in range(order):
val += weights[k]*func(x0+(k-ho)*dx,*args)
return val / product((dx,)*n,axis=0)
def lena():
"""
Function that previously returned an example image
.. note:: Removed in 0.17
Parameters
----------
None
Returns
-------
None
Raises
------
RuntimeError
This functionality has been removed due to licensing reasons.
Notes
-----
The image previously returned by this function has an incompatible license
and has been removed from SciPy. Please use `face` or `ascent` instead.
See Also
--------
face, ascent
"""
raise RuntimeError('lena() is no longer included in SciPy, please use '
'ascent() or face() instead')
def ascent():
"""
Get an 8-bit grayscale bit-depth, 512 x 512 derived image for easy use in demos
The image is derived from accent-to-the-top.jpg at
http://www.public-domain-image.com/people-public-domain-images-pictures/
Parameters
----------
None
Returns
-------
ascent : ndarray
convenient image to use for testing and demonstration
Examples
--------
>>> import scipy.misc
>>> ascent = scipy.misc.ascent()
>>> ascent.shape
(512, 512)
>>> ascent.max()
255
>>> import matplotlib.pyplot as plt
>>> plt.gray()
>>> plt.imshow(ascent)
>>> plt.show()
"""
import pickle
import os
fname = os.path.join(os.path.dirname(__file__),'ascent.dat')
with open(fname, 'rb') as f:
ascent = array(pickle.load(f))
return ascent
def face(gray=False):
"""
Get a 1024 x 768, color image of a raccoon face.
raccoon-procyon-lotor.jpg at http://www.public-domain-image.com
Parameters
----------
gray : bool, optional
If True return 8-bit grey-scale image, otherwise return a color image
Returns
-------
face : ndarray
image of a racoon face
Examples
--------
>>> import scipy.misc
>>> face = scipy.misc.face()
>>> face.shape
(768, 1024, 3)
>>> face.max()
255
>>> face.dtype
dtype('uint8')
>>> import matplotlib.pyplot as plt
>>> plt.gray()
>>> plt.imshow(face)
>>> plt.show()
"""
import bz2
import os
with open(os.path.join(os.path.dirname(__file__), 'face.dat'), 'rb') as f:
rawdata = f.read()
data = bz2.decompress(rawdata)
face = fromstring(data, dtype='uint8')
face.shape = (768, 1024, 3)
if gray is True:
face = (0.21 * face[:,:,0] + 0.71 * face[:,:,1] + 0.07 * face[:,:,2]).astype('uint8')
return face
| apache-2.0 |
aiguofer/bokeh | bokeh/charts/builders/line_builder.py | 4 | 9608 | """This is the Bokeh charts interface. It gives you a high level API to build
complex plot is a simple way.
This is the Line class which lets you build your Line charts just
passing the arguments to the Chart class and calling the proper functions.
"""
# -----------------------------------------------------------------------------
# Copyright (c) 2012 - 2014, Continuum Analytics, Inc. All rights reserved.
#
# Powered by the Bokeh Development Team.
#
# The full license is in the file LICENSE.txt, distributed with this software.
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
# Imports
# -----------------------------------------------------------------------------
from __future__ import absolute_import
from six import iteritems
from itertools import chain
from ..builder import XYBuilder, create_and_build
from ..glyphs import LineGlyph, PointGlyph
from ..attributes import DashAttr, ColorAttr, MarkerAttr
from ..data_source import NumericalColumnsAssigner
from ...models.sources import ColumnDataSource
from ...core.properties import Bool, String, List
from ..operations import Stack, Dodge
from ..utils import add_tooltips_columns
# -----------------------------------------------------------------------------
# Classes and functions
# -----------------------------------------------------------------------------
def Line(data=None, x=None, y=None, **kws):
""" Create a line chart using :class:`LineBuilder <bokeh.charts.builders.line_builder.LineBuilder>` to
render the glyphs.
The line chart is typically is used with column oriented data, where each column
contains comparable measurements and the column names are treated as a categorical
variable for differentiating the measurement values. One of the columns can be used as
an index for either the x or y axis.
.. note::
Only the x or y axis can display multiple variables, while the other is used
as an index.
Args:
data (list(list), numpy.ndarray, pandas.DataFrame, list(pd.Series)): a 2d data
source with columns of data for each line.
x (str or list(str), optional): specifies variable(s) to use for x axis
y (str or list(str), optional): specifies variable(s) to use for y axis
In addition to the parameters specific to this chart,
:ref:`userguide_charts_defaults` are also accepted as keyword parameters.
.. note::
This chart type differs on input types as compared to other charts,
due to the way that line charts typically are plotting labeled series. For
example, a column for AAPL stock prices over time. Another way this could be
plotted is to have a DataFrame with a column of `stock_label` and columns of
`price`, which is the stacked format. Both should be supported, but the former
is the expected one. Internally, the latter format is being derived.
Returns:
:class:`Chart`: includes glyph renderers that generate the lines
Examples:
.. bokeh-plot::
:source-position: above
import numpy as np
from bokeh.charts import Line, output_file, show
# (dict, OrderedDict, lists, arrays and DataFrames are valid inputs)
xyvalues = np.array([[2, 3, 7, 5, 26], [12, 33, 47, 15, 126], [22, 43, 10, 25, 26]])
line = Line(xyvalues, title="line", legend="top_left", ylabel='Languages')
output_file('line.html')
show(line)
"""
kws['x'] = x
kws['y'] = y
return create_and_build(LineBuilder, data, **kws)
class LineBuilder(XYBuilder):
"""This is the Line class and it is in charge of plotting
Line charts in an easy and intuitive way.
Essentially, we provide a way to ingest the data, make the proper
calculations and push the references into a source object.
We additionally make calculations for the ranges.
And finally add the needed lines taking the references from the source.
"""
series_names = List(String, help="""Names that represent the items being plotted.""")
stack = Bool(default=False)
default_attributes = {'color': ColorAttr(),
'dash': DashAttr(),
'marker': MarkerAttr()}
dimensions = ['y', 'x']
column_selector = NumericalColumnsAssigner
glyph = LineGlyph
@property
def measures(self):
if isinstance(self.y.selection, list):
return self.y.selection
elif isinstance(self.x.selection, list):
return self.x.selection
else:
return None
@property
def measure_input(self):
return isinstance(self.y.selection, list) or isinstance(self.x.selection, list)
@property
def stack_flags(self):
# Check if we stack measurements and by which attributes
# This happens if we used the same series labels for dimensions as attributes
return {k: self.attr_measurement(k) for k in list(
self.attributes.keys())}
def get_id_cols(self, stack_flags):
# collect the other columns used as identifiers, that aren't a measurement name
id_cols = [self.attributes[attr].columns
for attr, stack in iteritems(stack_flags) if not stack and
self.attributes[attr].columns != self.measures and
self.attributes[attr].columns is not None]
return list(chain.from_iterable(id_cols))
def setup(self):
"""Handle input options that require transforming data and/or user selections."""
# handle special case of inputs as measures
if self.measure_input:
stack_flags = self.stack_flags
id_cols = self.get_id_cols(stack_flags)
# if we have measures input, we need to stack by something, set default
if all(attr is False for attr in list(stack_flags.values())):
stack_flags['color'] = True
# stack the measurement dimension while keeping id columns
self._stack_measures(ids=id_cols)
# set the attributes to key off of the name of the stacked measurement
source = ColumnDataSource(self._data.df)
for attr_name, stack_flag in iteritems(stack_flags):
if stack_flags[attr_name]:
default_attr = self.attributes[attr_name]
default_attr.setup(columns='series', data=source)
# Handle when to use special column names
if self.x.selection is None and self.y.selection is not None:
self.x.selection = 'index'
elif self.x.selection is not None and self.y.selection is None:
self.y.selection = 'index'
def attr_measurement(self, attr_name):
"""Detect if the attribute has been given measurement columns."""
cols = self.attributes[attr_name].columns
return (cols is not None and (cols == self.y.selection or
cols == self.x.selection))
def set_series(self, col_name):
series = self._data.df[col_name].drop_duplicates().tolist()
series = [str(item) for item in series]
self.series_names = series
def _stack_measures(self, ids, var_name='series'):
"""Stack data and keep the ids columns.
Args:
ids (list(str)): the column names that describe the measures
"""
if isinstance(self.y.selection, list):
dim = 'y'
if self.x.selection is not None:
ids.append(self.x.selection)
else:
dim = 'x'
if self.y.selection is not None:
ids.append(self.y.selection)
if len(ids) == 0:
ids = None
dim_prop = getattr(self, dim)
# transform our data by stacking the measurements into one column
self._data.stack_measures(measures=dim_prop.selection, ids=ids,
var_name=var_name)
# update our dimension with the updated data
dim_prop.set_data(self._data)
self.set_series('series')
def get_builder_attr(self):
attrs = self.properties()
return {attr: getattr(self, attr) for attr in attrs
if attr in self.glyph.properties()}
def yield_renderers(self):
build_attr = self.get_builder_attr()
# get the list of builder attributes and only pass them on if glyph supports
attrs = list(self.attributes.keys())
attrs = [attr for attr in attrs if attr in self.glyph.properties()]
for group in self._data.groupby(**self.attributes):
group_kwargs = self.get_group_kwargs(group, attrs)
group_kwargs.update(build_attr)
glyph = self.glyph(label=group.label,
x=group.get_values(self.x.selection),
y=group.get_values(self.y.selection),
**group_kwargs)
# dash=group['dash']
# save reference to composite glyph
self.add_glyph(group, glyph)
# yield each renderer produced by composite glyph
for renderer in glyph.renderers:
if self.tooltips:
renderer = add_tooltips_columns(renderer, self.tooltips, group)
yield renderer
if self.stack:
Stack().apply(self.comp_glyphs)
Dodge().apply(self.comp_glyphs)
class PointSeriesBuilder(LineBuilder):
glyph = PointGlyph
| bsd-3-clause |
NunoEdgarGub1/scikit-learn | sklearn/utils/tests/test_multiclass.py | 72 | 15350 | from __future__ import division
import numpy as np
import scipy.sparse as sp
from itertools import product
from functools import partial
from sklearn.externals.six.moves import xrange
from sklearn.externals.six import iteritems
from scipy.sparse import issparse
from scipy.sparse import csc_matrix
from scipy.sparse import csr_matrix
from scipy.sparse import coo_matrix
from scipy.sparse import dok_matrix
from scipy.sparse import lil_matrix
from sklearn.utils.testing import assert_array_equal
from sklearn.utils.testing import assert_array_almost_equal
from sklearn.utils.testing import assert_equal
from sklearn.utils.testing import assert_true
from sklearn.utils.testing import assert_false
from sklearn.utils.testing import assert_raises
from sklearn.utils.testing import assert_warns
from sklearn.utils.testing import ignore_warnings
from sklearn.utils.multiclass import unique_labels
from sklearn.utils.multiclass import is_label_indicator_matrix
from sklearn.utils.multiclass import is_multilabel
from sklearn.utils.multiclass import is_sequence_of_sequences
from sklearn.utils.multiclass import type_of_target
from sklearn.utils.multiclass import class_distribution
class NotAnArray(object):
"""An object that is convertable to an array. This is useful to
simulate a Pandas timeseries."""
def __init__(self, data):
self.data = data
def __array__(self):
return self.data
EXAMPLES = {
'multilabel-indicator': [
# valid when the data is formated as sparse or dense, identified
# by CSR format when the testing takes place
csr_matrix(np.random.RandomState(42).randint(2, size=(10, 10))),
csr_matrix(np.array([[0, 1], [1, 0]])),
csr_matrix(np.array([[0, 1], [1, 0]], dtype=np.bool)),
csr_matrix(np.array([[0, 1], [1, 0]], dtype=np.int8)),
csr_matrix(np.array([[0, 1], [1, 0]], dtype=np.uint8)),
csr_matrix(np.array([[0, 1], [1, 0]], dtype=np.float)),
csr_matrix(np.array([[0, 1], [1, 0]], dtype=np.float32)),
csr_matrix(np.array([[0, 0], [0, 0]])),
csr_matrix(np.array([[0, 1]])),
# Only valid when data is dense
np.array([[-1, 1], [1, -1]]),
np.array([[-3, 3], [3, -3]]),
NotAnArray(np.array([[-3, 3], [3, -3]])),
],
'multilabel-sequences': [
[[0, 1]],
[[0], [1]],
[[1, 2, 3]],
[[1, 2, 1]], # duplicate values, why not?
[[1], [2], [0, 1]],
[[1], [2]],
[[]],
[()],
np.array([[], [1, 2]], dtype='object'),
NotAnArray(np.array([[], [1, 2]], dtype='object')),
],
'multiclass': [
[1, 0, 2, 2, 1, 4, 2, 4, 4, 4],
np.array([1, 0, 2]),
np.array([1, 0, 2], dtype=np.int8),
np.array([1, 0, 2], dtype=np.uint8),
np.array([1, 0, 2], dtype=np.float),
np.array([1, 0, 2], dtype=np.float32),
np.array([[1], [0], [2]]),
NotAnArray(np.array([1, 0, 2])),
[0, 1, 2],
['a', 'b', 'c'],
np.array([u'a', u'b', u'c']),
np.array([u'a', u'b', u'c'], dtype=object),
np.array(['a', 'b', 'c'], dtype=object),
],
'multiclass-multioutput': [
np.array([[1, 0, 2, 2], [1, 4, 2, 4]]),
np.array([[1, 0, 2, 2], [1, 4, 2, 4]], dtype=np.int8),
np.array([[1, 0, 2, 2], [1, 4, 2, 4]], dtype=np.uint8),
np.array([[1, 0, 2, 2], [1, 4, 2, 4]], dtype=np.float),
np.array([[1, 0, 2, 2], [1, 4, 2, 4]], dtype=np.float32),
np.array([['a', 'b'], ['c', 'd']]),
np.array([[u'a', u'b'], [u'c', u'd']]),
np.array([[u'a', u'b'], [u'c', u'd']], dtype=object),
np.array([[1, 0, 2]]),
NotAnArray(np.array([[1, 0, 2]])),
],
'binary': [
[0, 1],
[1, 1],
[],
[0],
np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1]),
np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1], dtype=np.bool),
np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1], dtype=np.int8),
np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1], dtype=np.uint8),
np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1], dtype=np.float),
np.array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1], dtype=np.float32),
np.array([[0], [1]]),
NotAnArray(np.array([[0], [1]])),
[1, -1],
[3, 5],
['a'],
['a', 'b'],
['abc', 'def'],
np.array(['abc', 'def']),
[u'a', u'b'],
np.array(['abc', 'def'], dtype=object),
],
'continuous': [
[1e-5],
[0, .5],
np.array([[0], [.5]]),
np.array([[0], [.5]], dtype=np.float32),
],
'continuous-multioutput': [
np.array([[0, .5], [.5, 0]]),
np.array([[0, .5], [.5, 0]], dtype=np.float32),
np.array([[0, .5]]),
],
'unknown': [
# empty second dimension
np.array([[], []]),
# 3d
np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]),
# not currently supported sequence of sequences
np.array([np.array([]), np.array([1, 2, 3])], dtype=object),
[np.array([]), np.array([1, 2, 3])],
[set([1, 2, 3]), set([1, 2])],
[frozenset([1, 2, 3]), frozenset([1, 2])],
# and also confusable as sequences of sequences
[{0: 'a', 1: 'b'}, {0: 'a'}],
]
}
NON_ARRAY_LIKE_EXAMPLES = [
set([1, 2, 3]),
{0: 'a', 1: 'b'},
{0: [5], 1: [5]},
'abc',
frozenset([1, 2, 3]),
None,
]
def test_unique_labels():
# Empty iterable
assert_raises(ValueError, unique_labels)
# Multiclass problem
assert_array_equal(unique_labels(xrange(10)), np.arange(10))
assert_array_equal(unique_labels(np.arange(10)), np.arange(10))
assert_array_equal(unique_labels([4, 0, 2]), np.array([0, 2, 4]))
# Multilabels
assert_array_equal(assert_warns(DeprecationWarning,
unique_labels,
[(0, 1, 2), (0,), tuple(), (2, 1)]),
np.arange(3))
assert_array_equal(assert_warns(DeprecationWarning,
unique_labels,
[[0, 1, 2], [0], list(), [2, 1]]),
np.arange(3))
assert_array_equal(unique_labels(np.array([[0, 0, 1],
[1, 0, 1],
[0, 0, 0]])),
np.arange(3))
assert_array_equal(unique_labels(np.array([[0, 0, 1],
[0, 0, 0]])),
np.arange(3))
# Several arrays passed
assert_array_equal(unique_labels([4, 0, 2], xrange(5)),
np.arange(5))
assert_array_equal(unique_labels((0, 1, 2), (0,), (2, 1)),
np.arange(3))
# Border line case with binary indicator matrix
assert_raises(ValueError, unique_labels, [4, 0, 2], np.ones((5, 5)))
assert_raises(ValueError, unique_labels, np.ones((5, 4)), np.ones((5, 5)))
assert_array_equal(unique_labels(np.ones((4, 5)), np.ones((5, 5))),
np.arange(5))
# Some tests with strings input
assert_array_equal(unique_labels(["a", "b", "c"], ["d"]),
["a", "b", "c", "d"])
assert_array_equal(assert_warns(DeprecationWarning, unique_labels,
[["a", "b"], ["c"]], [["d"]]),
["a", "b", "c", "d"])
@ignore_warnings
def test_unique_labels_non_specific():
# Test unique_labels with a variety of collected examples
# Smoke test for all supported format
for format in ["binary", "multiclass", "multilabel-sequences",
"multilabel-indicator"]:
for y in EXAMPLES[format]:
unique_labels(y)
# We don't support those format at the moment
for example in NON_ARRAY_LIKE_EXAMPLES:
assert_raises(ValueError, unique_labels, example)
for y_type in ["unknown", "continuous", 'continuous-multioutput',
'multiclass-multioutput']:
for example in EXAMPLES[y_type]:
assert_raises(ValueError, unique_labels, example)
@ignore_warnings
def test_unique_labels_mixed_types():
# Mix of multilabel-indicator and multilabel-sequences
mix_multilabel_format = product(EXAMPLES["multilabel-indicator"],
EXAMPLES["multilabel-sequences"])
for y_multilabel, y_multiclass in mix_multilabel_format:
assert_raises(ValueError, unique_labels, y_multiclass, y_multilabel)
assert_raises(ValueError, unique_labels, y_multilabel, y_multiclass)
# Mix with binary or multiclass and multilabel
mix_clf_format = product(EXAMPLES["multilabel-indicator"] +
EXAMPLES["multilabel-sequences"],
EXAMPLES["multiclass"] +
EXAMPLES["binary"])
for y_multilabel, y_multiclass in mix_clf_format:
assert_raises(ValueError, unique_labels, y_multiclass, y_multilabel)
assert_raises(ValueError, unique_labels, y_multilabel, y_multiclass)
# Mix string and number input type
assert_raises(ValueError, unique_labels, [[1, 2], [3]],
[["a", "d"]])
assert_raises(ValueError, unique_labels, ["1", 2])
assert_raises(ValueError, unique_labels, [["1", 2], [3]])
assert_raises(ValueError, unique_labels, [["1", "2"], [3]])
assert_array_equal(unique_labels([(2,), (0, 2,)], [(), ()]), [0, 2])
assert_array_equal(unique_labels([("2",), ("0", "2",)], [(), ()]),
["0", "2"])
@ignore_warnings
def test_is_multilabel():
for group, group_examples in iteritems(EXAMPLES):
if group.startswith('multilabel'):
assert_, exp = assert_true, 'True'
else:
assert_, exp = assert_false, 'False'
for example in group_examples:
assert_(is_multilabel(example),
msg='is_multilabel(%r) should be %s' % (example, exp))
def test_is_label_indicator_matrix():
for group, group_examples in iteritems(EXAMPLES):
if group in ['multilabel-indicator']:
dense_assert_, dense_exp = assert_true, 'True'
else:
dense_assert_, dense_exp = assert_false, 'False'
for example in group_examples:
# Only mark explicitly defined sparse examples as valid sparse
# multilabel-indicators
if group == 'multilabel-indicator' and issparse(example):
sparse_assert_, sparse_exp = assert_true, 'True'
else:
sparse_assert_, sparse_exp = assert_false, 'False'
if (issparse(example) or
(hasattr(example, '__array__') and
np.asarray(example).ndim == 2 and
np.asarray(example).dtype.kind in 'biuf' and
np.asarray(example).shape[1] > 0)):
examples_sparse = [sparse_matrix(example)
for sparse_matrix in [coo_matrix,
csc_matrix,
csr_matrix,
dok_matrix,
lil_matrix]]
for exmpl_sparse in examples_sparse:
sparse_assert_(is_label_indicator_matrix(exmpl_sparse),
msg=('is_label_indicator_matrix(%r)'
' should be %s')
% (exmpl_sparse, sparse_exp))
# Densify sparse examples before testing
if issparse(example):
example = example.toarray()
dense_assert_(is_label_indicator_matrix(example),
msg='is_label_indicator_matrix(%r) should be %s'
% (example, dense_exp))
def test_is_sequence_of_sequences():
for group, group_examples in iteritems(EXAMPLES):
if group == 'multilabel-sequences':
assert_, exp = assert_true, 'True'
check = partial(assert_warns, DeprecationWarning,
is_sequence_of_sequences)
else:
assert_, exp = assert_false, 'False'
check = is_sequence_of_sequences
for example in group_examples:
assert_(check(example),
msg='is_sequence_of_sequences(%r) should be %s'
% (example, exp))
@ignore_warnings
def test_type_of_target():
for group, group_examples in iteritems(EXAMPLES):
for example in group_examples:
assert_equal(type_of_target(example), group,
msg='type_of_target(%r) should be %r, got %r'
% (example, group, type_of_target(example)))
for example in NON_ARRAY_LIKE_EXAMPLES:
assert_raises(ValueError, type_of_target, example)
def test_class_distribution():
y = np.array([[1, 0, 0, 1],
[2, 2, 0, 1],
[1, 3, 0, 1],
[4, 2, 0, 1],
[2, 0, 0, 1],
[1, 3, 0, 1]])
# Define the sparse matrix with a mix of implicit and explicit zeros
data = np.array([1, 2, 1, 4, 2, 1, 0, 2, 3, 2, 3, 1, 1, 1, 1, 1, 1])
indices = np.array([0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 5, 0, 1, 2, 3, 4, 5])
indptr = np.array([0, 6, 11, 11, 17])
y_sp = sp.csc_matrix((data, indices, indptr), shape=(6, 4))
classes, n_classes, class_prior = class_distribution(y)
classes_sp, n_classes_sp, class_prior_sp = class_distribution(y_sp)
classes_expected = [[1, 2, 4],
[0, 2, 3],
[0],
[1]]
n_classes_expected = [3, 3, 1, 1]
class_prior_expected = [[3/6, 2/6, 1/6],
[1/3, 1/3, 1/3],
[1.0],
[1.0]]
for k in range(y.shape[1]):
assert_array_almost_equal(classes[k], classes_expected[k])
assert_array_almost_equal(n_classes[k], n_classes_expected[k])
assert_array_almost_equal(class_prior[k], class_prior_expected[k])
assert_array_almost_equal(classes_sp[k], classes_expected[k])
assert_array_almost_equal(n_classes_sp[k], n_classes_expected[k])
assert_array_almost_equal(class_prior_sp[k], class_prior_expected[k])
# Test again with explicit sample weights
(classes,
n_classes,
class_prior) = class_distribution(y, [1.0, 2.0, 1.0, 2.0, 1.0, 2.0])
(classes_sp,
n_classes_sp,
class_prior_sp) = class_distribution(y, [1.0, 2.0, 1.0, 2.0, 1.0, 2.0])
class_prior_expected = [[4/9, 3/9, 2/9],
[2/9, 4/9, 3/9],
[1.0],
[1.0]]
for k in range(y.shape[1]):
assert_array_almost_equal(classes[k], classes_expected[k])
assert_array_almost_equal(n_classes[k], n_classes_expected[k])
assert_array_almost_equal(class_prior[k], class_prior_expected[k])
assert_array_almost_equal(classes_sp[k], classes_expected[k])
assert_array_almost_equal(n_classes_sp[k], n_classes_expected[k])
assert_array_almost_equal(class_prior_sp[k], class_prior_expected[k])
| bsd-3-clause |
simonsfoundation/CaImAn | use_cases/eLife_scripts/train_cnns/train_net_cifar.py | 2 | 7940 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Created on Thu Aug 24 12:30:19 2017
@author: agiovann
"""
'''From keras example of convnet on the MNIST dataset.
Gets to 99.25% test accuracy after 12 epochs
(there is still a lot of margin for parameter tuning).
16 seconds per epoch on a GRID K520 GPU.
'''
#%%
from __future__ import division
from __future__ import print_function
from builtins import zip
from builtins import str
from builtins import map
from builtins import range
from past.utils import old_div
import cv2
import glob
try:
cv2.setNumThreads(1)
except:
print('Open CV is naturally single threaded')
try:
if __IPYTHON__:
print(1)
# this is used for debugging purposes only. allows to reload classes
# when changed
get_ipython().magic('load_ext autoreload')
get_ipython().magic('autoreload 2')
except NameError:
print('Not launched under iPython')
import caiman as cm
import numpy as np
import os
import time
import pylab as pl
import psutil
import sys
from ipyparallel import Client
from skimage.external.tifffile import TiffFile
import scipy
import copy
from caiman.utils.utils import download_demo
from caiman.base.rois import extract_binary_masks_blob
from caiman.utils.visualization import plot_contours, view_patches_bar
from caiman.source_extraction.cnmf import cnmf as cnmf
from caiman.motion_correction import MotionCorrect
from caiman.components_evaluation import estimate_components_quality
from caiman.components_evaluation import evaluate_components
from caiman.tests.comparison import comparison
from caiman.motion_correction import tile_and_correct, motion_correction_piecewise
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K
from sklearn.model_selection import train_test_split
from keras.layers import Dense, Dropout, Activation, Flatten
from caiman.utils.image_preprocessing_keras import ImageDataGenerator
import json as simplejson
from keras.models import model_from_json
from sklearn.utils import class_weight as cw
#%%
# the data, shuffled and split between train and test sets
with np.load('use_cases/CaImAnpaper/ground_truth_comoponents_curated.npz') as ld:
all_masks_gt = ld['all_masks_gt']
labels_gt = ld['labels_gt_cur']
#%%
batch_size = 128
num_classes = 2
epochs = 5000
test_fraction = 0.25
augmentation = True
# input image dimensions
img_rows, img_cols = 50, 50
x_train, x_test, y_train, y_test = train_test_split(
all_masks_gt, labels_gt, test_size=test_fraction)
class_weight = cw.compute_class_weight('balanced', np.unique(y_train), y_train)
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
#x_train /= 255
#x_test /= 255
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
#%%
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes))
model.add(Activation('softmax'))
# initiate RMSprop optimizer
opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=opt,
metrics=['accuracy'])
if augmentation:
print('Using real-time data augmentation.')
# This will do preprocessing and realtime data augmentation:
datagen = ImageDataGenerator(
# featurewise_center=True,
# featurewise_std_normalization=True,
shear_range=0.3,
rotation_range=360,
width_shift_range=0.2,
height_shift_range=0.2,
zoom_range=[0.8, 1.2],
horizontal_flip=True,
vertical_flip=True,
random_mult_range=[.25, 2]
)
# Compute quantities required for feature-wise normalization
# (std, mean, and principal components if ZCA whitening is applied).
datagen.fit(x_train)
# Fit the model on the batches generated by datagen.flow().
model.fit_generator(datagen.flow(x_train, y_train,
batch_size=batch_size),
steps_per_epoch=x_train.shape[0] // batch_size,
epochs=epochs,
verbose=1,
class_weight=class_weight,
validation_data=(x_test, y_test))
else:
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_test, y_test))
#%%
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
#%% Save model and weights
save_dir = 'use_cases/CaImAnpaper/'
model_name = str(datetime.datetime.now()).replace(' ', '-').replace(':', '-')
model_json = model.to_json()
json_path = os.path.join(save_dir, model_name + '.json')
with open(json_path, "w") as json_file:
json_file.write(simplejson.dumps(simplejson.loads(model_json), indent=4))
print('Saved trained model at %s ' % json_path)
if not os.path.isdir(save_dir):
os.makedirs(save_dir)
model_path = os.path.join(save_dir, model_name + '.h5')
model.save(model_path)
print('Saved trained model at %s ' % model_path)
#%% visualize_results
predictions = model.predict(all_masks_gt, batch_size=32, verbose=1)
cm.movie(np.squeeze(all_masks_gt[np.where(predictions[:, 0] >= 0.5)[0]])).play(
gain=3., magnification=5, fr=10)
#%%
cm.movie(np.squeeze(all_masks_gt[np.where(predictions[:, 1] >= 0.5)[0]])).play(
gain=3., magnification=5, fr=10)
#%% retrieve and test
json_file = open(json_path, 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
loaded_model.load_weights(model_path)
opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)
loaded_model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=opt,
metrics=['accuracy'])
print("Loaded model from disk")
score = loaded_model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
score = loaded_model.evaluate(x_train, y_train, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
#%%
from skimage.util.montage import montage2d
predictions = loaded_model.predict(all_masks_gt, batch_size=32, verbose=1)
cm.movie(np.squeeze(all_masks_gt[np.where(predictions[:, 1] < 0.1)[0]])).play(
gain=3., magnification=5, fr=10)
#%%
pl.imshow(montage2d(all_masks_gt[np.where((labels_gt == 0) & (
predictions[:, 1] >= 0.5) & (predictions[:, 1] >= 0.5))[0]].squeeze()))
#%%
pl.imshow(montage2d(all_masks_gt[np.where((labels_gt == 1) & (
predictions[:, 0] >= 0.5) & (predictions[:, 0] >= 0.5))[0]].squeeze()))
| gpl-2.0 |
yyjiang/scikit-learn | sklearn/cluster/tests/test_birch.py | 342 | 5603 | """
Tests for the birch clustering algorithm.
"""
from scipy import sparse
import numpy as np
from sklearn.cluster.tests.common import generate_clustered_data
from sklearn.cluster.birch import Birch
from sklearn.cluster.hierarchical import AgglomerativeClustering
from sklearn.datasets import make_blobs
from sklearn.linear_model import ElasticNet
from sklearn.metrics import pairwise_distances_argmin, v_measure_score
from sklearn.utils.testing import assert_greater_equal
from sklearn.utils.testing import assert_equal
from sklearn.utils.testing import assert_greater
from sklearn.utils.testing import assert_almost_equal
from sklearn.utils.testing import assert_array_equal
from sklearn.utils.testing import assert_raises
from sklearn.utils.testing import assert_warns
def test_n_samples_leaves_roots():
# Sanity check for the number of samples in leaves and roots
X, y = make_blobs(n_samples=10)
brc = Birch()
brc.fit(X)
n_samples_root = sum([sc.n_samples_ for sc in brc.root_.subclusters_])
n_samples_leaves = sum([sc.n_samples_ for leaf in brc._get_leaves()
for sc in leaf.subclusters_])
assert_equal(n_samples_leaves, X.shape[0])
assert_equal(n_samples_root, X.shape[0])
def test_partial_fit():
# Test that fit is equivalent to calling partial_fit multiple times
X, y = make_blobs(n_samples=100)
brc = Birch(n_clusters=3)
brc.fit(X)
brc_partial = Birch(n_clusters=None)
brc_partial.partial_fit(X[:50])
brc_partial.partial_fit(X[50:])
assert_array_equal(brc_partial.subcluster_centers_,
brc.subcluster_centers_)
# Test that same global labels are obtained after calling partial_fit
# with None
brc_partial.set_params(n_clusters=3)
brc_partial.partial_fit(None)
assert_array_equal(brc_partial.subcluster_labels_, brc.subcluster_labels_)
def test_birch_predict():
# Test the predict method predicts the nearest centroid.
rng = np.random.RandomState(0)
X = generate_clustered_data(n_clusters=3, n_features=3,
n_samples_per_cluster=10)
# n_samples * n_samples_per_cluster
shuffle_indices = np.arange(30)
rng.shuffle(shuffle_indices)
X_shuffle = X[shuffle_indices, :]
brc = Birch(n_clusters=4, threshold=1.)
brc.fit(X_shuffle)
centroids = brc.subcluster_centers_
assert_array_equal(brc.labels_, brc.predict(X_shuffle))
nearest_centroid = pairwise_distances_argmin(X_shuffle, centroids)
assert_almost_equal(v_measure_score(nearest_centroid, brc.labels_), 1.0)
def test_n_clusters():
# Test that n_clusters param works properly
X, y = make_blobs(n_samples=100, centers=10)
brc1 = Birch(n_clusters=10)
brc1.fit(X)
assert_greater(len(brc1.subcluster_centers_), 10)
assert_equal(len(np.unique(brc1.labels_)), 10)
# Test that n_clusters = Agglomerative Clustering gives
# the same results.
gc = AgglomerativeClustering(n_clusters=10)
brc2 = Birch(n_clusters=gc)
brc2.fit(X)
assert_array_equal(brc1.subcluster_labels_, brc2.subcluster_labels_)
assert_array_equal(brc1.labels_, brc2.labels_)
# Test that the wrong global clustering step raises an Error.
clf = ElasticNet()
brc3 = Birch(n_clusters=clf)
assert_raises(ValueError, brc3.fit, X)
# Test that a small number of clusters raises a warning.
brc4 = Birch(threshold=10000.)
assert_warns(UserWarning, brc4.fit, X)
def test_sparse_X():
# Test that sparse and dense data give same results
X, y = make_blobs(n_samples=100, centers=10)
brc = Birch(n_clusters=10)
brc.fit(X)
csr = sparse.csr_matrix(X)
brc_sparse = Birch(n_clusters=10)
brc_sparse.fit(csr)
assert_array_equal(brc.labels_, brc_sparse.labels_)
assert_array_equal(brc.subcluster_centers_,
brc_sparse.subcluster_centers_)
def check_branching_factor(node, branching_factor):
subclusters = node.subclusters_
assert_greater_equal(branching_factor, len(subclusters))
for cluster in subclusters:
if cluster.child_:
check_branching_factor(cluster.child_, branching_factor)
def test_branching_factor():
# Test that nodes have at max branching_factor number of subclusters
X, y = make_blobs()
branching_factor = 9
# Purposefully set a low threshold to maximize the subclusters.
brc = Birch(n_clusters=None, branching_factor=branching_factor,
threshold=0.01)
brc.fit(X)
check_branching_factor(brc.root_, branching_factor)
brc = Birch(n_clusters=3, branching_factor=branching_factor,
threshold=0.01)
brc.fit(X)
check_branching_factor(brc.root_, branching_factor)
# Raises error when branching_factor is set to one.
brc = Birch(n_clusters=None, branching_factor=1, threshold=0.01)
assert_raises(ValueError, brc.fit, X)
def check_threshold(birch_instance, threshold):
"""Use the leaf linked list for traversal"""
current_leaf = birch_instance.dummy_leaf_.next_leaf_
while current_leaf:
subclusters = current_leaf.subclusters_
for sc in subclusters:
assert_greater_equal(threshold, sc.radius)
current_leaf = current_leaf.next_leaf_
def test_threshold():
# Test that the leaf subclusters have a threshold lesser than radius
X, y = make_blobs(n_samples=80, centers=4)
brc = Birch(threshold=0.5, n_clusters=None)
brc.fit(X)
check_threshold(brc, 0.5)
brc = Birch(threshold=5.0, n_clusters=None)
brc.fit(X)
check_threshold(brc, 5.)
| bsd-3-clause |
lancezlin/ml_template_py | lib/python2.7/site-packages/sklearn/linear_model/tests/test_randomized_l1.py | 57 | 4736 | # Authors: Alexandre Gramfort <[email protected]>
# License: BSD 3 clause
import numpy as np
from scipy import sparse
from sklearn.utils.testing import assert_equal
from sklearn.utils.testing import assert_array_equal
from sklearn.utils.testing import assert_raises
from sklearn.linear_model.randomized_l1 import (lasso_stability_path,
RandomizedLasso,
RandomizedLogisticRegression)
from sklearn.datasets import load_diabetes, load_iris
from sklearn.feature_selection import f_regression, f_classif
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model.base import _preprocess_data
diabetes = load_diabetes()
X = diabetes.data
y = diabetes.target
X = StandardScaler().fit_transform(X)
X = X[:, [2, 3, 6, 7, 8]]
# test that the feature score of the best features
F, _ = f_regression(X, y)
def test_lasso_stability_path():
# Check lasso stability path
# Load diabetes data and add noisy features
scaling = 0.3
coef_grid, scores_path = lasso_stability_path(X, y, scaling=scaling,
random_state=42,
n_resampling=30)
assert_array_equal(np.argsort(F)[-3:],
np.argsort(np.sum(scores_path, axis=1))[-3:])
def test_randomized_lasso():
# Check randomized lasso
scaling = 0.3
selection_threshold = 0.5
# or with 1 alpha
clf = RandomizedLasso(verbose=False, alpha=1, random_state=42,
scaling=scaling,
selection_threshold=selection_threshold)
feature_scores = clf.fit(X, y).scores_
assert_array_equal(np.argsort(F)[-3:], np.argsort(feature_scores)[-3:])
# or with many alphas
clf = RandomizedLasso(verbose=False, alpha=[1, 0.8], random_state=42,
scaling=scaling,
selection_threshold=selection_threshold)
feature_scores = clf.fit(X, y).scores_
assert_equal(clf.all_scores_.shape, (X.shape[1], 2))
assert_array_equal(np.argsort(F)[-3:], np.argsort(feature_scores)[-3:])
X_r = clf.transform(X)
X_full = clf.inverse_transform(X_r)
assert_equal(X_r.shape[1], np.sum(feature_scores > selection_threshold))
assert_equal(X_full.shape, X.shape)
clf = RandomizedLasso(verbose=False, alpha='aic', random_state=42,
scaling=scaling)
feature_scores = clf.fit(X, y).scores_
assert_array_equal(feature_scores, X.shape[1] * [1.])
clf = RandomizedLasso(verbose=False, scaling=-0.1)
assert_raises(ValueError, clf.fit, X, y)
clf = RandomizedLasso(verbose=False, scaling=1.1)
assert_raises(ValueError, clf.fit, X, y)
def test_randomized_logistic():
# Check randomized sparse logistic regression
iris = load_iris()
X = iris.data[:, [0, 2]]
y = iris.target
X = X[y != 2]
y = y[y != 2]
F, _ = f_classif(X, y)
scaling = 0.3
clf = RandomizedLogisticRegression(verbose=False, C=1., random_state=42,
scaling=scaling, n_resampling=50,
tol=1e-3)
X_orig = X.copy()
feature_scores = clf.fit(X, y).scores_
assert_array_equal(X, X_orig) # fit does not modify X
assert_array_equal(np.argsort(F), np.argsort(feature_scores))
clf = RandomizedLogisticRegression(verbose=False, C=[1., 0.5],
random_state=42, scaling=scaling,
n_resampling=50, tol=1e-3)
feature_scores = clf.fit(X, y).scores_
assert_array_equal(np.argsort(F), np.argsort(feature_scores))
def test_randomized_logistic_sparse():
# Check randomized sparse logistic regression on sparse data
iris = load_iris()
X = iris.data[:, [0, 2]]
y = iris.target
X = X[y != 2]
y = y[y != 2]
# center here because sparse matrices are usually not centered
# labels should not be centered
X, _, _, _, _ = _preprocess_data(X, y, True, True)
X_sp = sparse.csr_matrix(X)
F, _ = f_classif(X, y)
scaling = 0.3
clf = RandomizedLogisticRegression(verbose=False, C=1., random_state=42,
scaling=scaling, n_resampling=50,
tol=1e-3)
feature_scores = clf.fit(X, y).scores_
clf = RandomizedLogisticRegression(verbose=False, C=1., random_state=42,
scaling=scaling, n_resampling=50,
tol=1e-3)
feature_scores_sp = clf.fit(X_sp, y).scores_
assert_array_equal(feature_scores, feature_scores_sp)
| mit |
mbayon/TFG-MachineLearning | vbig/lib/python2.7/site-packages/sklearn/gaussian_process/gpr.py | 9 | 20273 | """Gaussian processes regression. """
# Authors: Jan Hendrik Metzen <[email protected]>
#
# License: BSD 3 clause
import warnings
from operator import itemgetter
import numpy as np
from scipy.linalg import cholesky, cho_solve, solve_triangular
from scipy.optimize import fmin_l_bfgs_b
from sklearn.base import BaseEstimator, RegressorMixin, clone
from sklearn.gaussian_process.kernels import RBF, ConstantKernel as C
from sklearn.utils import check_random_state
from sklearn.utils.validation import check_X_y, check_array
from sklearn.utils.deprecation import deprecated
class GaussianProcessRegressor(BaseEstimator, RegressorMixin):
"""Gaussian process regression (GPR).
The implementation is based on Algorithm 2.1 of Gaussian Processes
for Machine Learning (GPML) by Rasmussen and Williams.
In addition to standard scikit-learn estimator API,
GaussianProcessRegressor:
* allows prediction without prior fitting (based on the GP prior)
* provides an additional method sample_y(X), which evaluates samples
drawn from the GPR (prior or posterior) at given inputs
* exposes a method log_marginal_likelihood(theta), which can be used
externally for other ways of selecting hyperparameters, e.g., via
Markov chain Monte Carlo.
Read more in the :ref:`User Guide <gaussian_process>`.
.. versionadded:: 0.18
Parameters
----------
kernel : kernel object
The kernel specifying the covariance function of the GP. If None is
passed, the kernel "1.0 * RBF(1.0)" is used as default. Note that
the kernel's hyperparameters are optimized during fitting.
alpha : float or array-like, optional (default: 1e-10)
Value added to the diagonal of the kernel matrix during fitting.
Larger values correspond to increased noise level in the observations.
This can also prevent a potential numerical issue during fitting, by
ensuring that the calculated values form a positive definite matrix.
If an array is passed, it must have the same number of entries as the
data used for fitting and is used as datapoint-dependent noise level.
Note that this is equivalent to adding a WhiteKernel with c=alpha.
Allowing to specify the noise level directly as a parameter is mainly
for convenience and for consistency with Ridge.
optimizer : string or callable, optional (default: "fmin_l_bfgs_b")
Can either be one of the internally supported optimizers for optimizing
the kernel's parameters, specified by a string, or an externally
defined optimizer passed as a callable. If a callable is passed, it
must have the signature::
def optimizer(obj_func, initial_theta, bounds):
# * 'obj_func' is the objective function to be maximized, which
# takes the hyperparameters theta as parameter and an
# optional flag eval_gradient, which determines if the
# gradient is returned additionally to the function value
# * 'initial_theta': the initial value for theta, which can be
# used by local optimizers
# * 'bounds': the bounds on the values of theta
....
# Returned are the best found hyperparameters theta and
# the corresponding value of the target function.
return theta_opt, func_min
Per default, the 'fmin_l_bfgs_b' algorithm from scipy.optimize
is used. If None is passed, the kernel's parameters are kept fixed.
Available internal optimizers are::
'fmin_l_bfgs_b'
n_restarts_optimizer : int, optional (default: 0)
The number of restarts of the optimizer for finding the kernel's
parameters which maximize the log-marginal likelihood. The first run
of the optimizer is performed from the kernel's initial parameters,
the remaining ones (if any) from thetas sampled log-uniform randomly
from the space of allowed theta-values. If greater than 0, all bounds
must be finite. Note that n_restarts_optimizer == 0 implies that one
run is performed.
normalize_y : boolean, optional (default: False)
Whether the target values y are normalized, i.e., the mean of the
observed target values become zero. This parameter should be set to
True if the target values' mean is expected to differ considerable from
zero. When enabled, the normalization effectively modifies the GP's
prior based on the data, which contradicts the likelihood principle;
normalization is thus disabled per default.
copy_X_train : bool, optional (default: True)
If True, a persistent copy of the training data is stored in the
object. Otherwise, just a reference to the training data is stored,
which might cause predictions to change if the data is modified
externally.
random_state : int, RandomState instance or None, optional (default: None)
The generator used to initialize the centers. If int, random_state is
the seed used by the random number generator; If RandomState instance,
random_state is the random number generator; If None, the random number
generator is the RandomState instance used by `np.random`.
Attributes
----------
X_train_ : array-like, shape = (n_samples, n_features)
Feature values in training data (also required for prediction)
y_train_ : array-like, shape = (n_samples, [n_output_dims])
Target values in training data (also required for prediction)
kernel_ : kernel object
The kernel used for prediction. The structure of the kernel is the
same as the one passed as parameter but with optimized hyperparameters
L_ : array-like, shape = (n_samples, n_samples)
Lower-triangular Cholesky decomposition of the kernel in ``X_train_``
alpha_ : array-like, shape = (n_samples,)
Dual coefficients of training data points in kernel space
log_marginal_likelihood_value_ : float
The log-marginal-likelihood of ``self.kernel_.theta``
"""
def __init__(self, kernel=None, alpha=1e-10,
optimizer="fmin_l_bfgs_b", n_restarts_optimizer=0,
normalize_y=False, copy_X_train=True, random_state=None):
self.kernel = kernel
self.alpha = alpha
self.optimizer = optimizer
self.n_restarts_optimizer = n_restarts_optimizer
self.normalize_y = normalize_y
self.copy_X_train = copy_X_train
self.random_state = random_state
@property
@deprecated("Attribute rng was deprecated in version 0.19 and "
"will be removed in 0.21.")
def rng(self):
return self._rng
@property
@deprecated("Attribute y_train_mean was deprecated in version 0.19 and "
"will be removed in 0.21.")
def y_train_mean(self):
return self._y_train_mean
def fit(self, X, y):
"""Fit Gaussian process regression model.
Parameters
----------
X : array-like, shape = (n_samples, n_features)
Training data
y : array-like, shape = (n_samples, [n_output_dims])
Target values
Returns
-------
self : returns an instance of self.
"""
if self.kernel is None: # Use an RBF kernel as default
self.kernel_ = C(1.0, constant_value_bounds="fixed") \
* RBF(1.0, length_scale_bounds="fixed")
else:
self.kernel_ = clone(self.kernel)
self._rng = check_random_state(self.random_state)
X, y = check_X_y(X, y, multi_output=True, y_numeric=True)
# Normalize target value
if self.normalize_y:
self._y_train_mean = np.mean(y, axis=0)
# demean y
y = y - self._y_train_mean
else:
self._y_train_mean = np.zeros(1)
if np.iterable(self.alpha) \
and self.alpha.shape[0] != y.shape[0]:
if self.alpha.shape[0] == 1:
self.alpha = self.alpha[0]
else:
raise ValueError("alpha must be a scalar or an array"
" with same number of entries as y.(%d != %d)"
% (self.alpha.shape[0], y.shape[0]))
self.X_train_ = np.copy(X) if self.copy_X_train else X
self.y_train_ = np.copy(y) if self.copy_X_train else y
if self.optimizer is not None and self.kernel_.n_dims > 0:
# Choose hyperparameters based on maximizing the log-marginal
# likelihood (potentially starting from several initial values)
def obj_func(theta, eval_gradient=True):
if eval_gradient:
lml, grad = self.log_marginal_likelihood(
theta, eval_gradient=True)
return -lml, -grad
else:
return -self.log_marginal_likelihood(theta)
# First optimize starting from theta specified in kernel
optima = [(self._constrained_optimization(obj_func,
self.kernel_.theta,
self.kernel_.bounds))]
# Additional runs are performed from log-uniform chosen initial
# theta
if self.n_restarts_optimizer > 0:
if not np.isfinite(self.kernel_.bounds).all():
raise ValueError(
"Multiple optimizer restarts (n_restarts_optimizer>0) "
"requires that all bounds are finite.")
bounds = self.kernel_.bounds
for iteration in range(self.n_restarts_optimizer):
theta_initial = \
self._rng.uniform(bounds[:, 0], bounds[:, 1])
optima.append(
self._constrained_optimization(obj_func, theta_initial,
bounds))
# Select result from run with minimal (negative) log-marginal
# likelihood
lml_values = list(map(itemgetter(1), optima))
self.kernel_.theta = optima[np.argmin(lml_values)][0]
self.log_marginal_likelihood_value_ = -np.min(lml_values)
else:
self.log_marginal_likelihood_value_ = \
self.log_marginal_likelihood(self.kernel_.theta)
# Precompute quantities required for predictions which are independent
# of actual query points
K = self.kernel_(self.X_train_)
K[np.diag_indices_from(K)] += self.alpha
try:
self.L_ = cholesky(K, lower=True) # Line 2
except np.linalg.LinAlgError as exc:
exc.args = ("The kernel, %s, is not returning a "
"positive definite matrix. Try gradually "
"increasing the 'alpha' parameter of your "
"GaussianProcessRegressor estimator."
% self.kernel_,) + exc.args
raise
self.alpha_ = cho_solve((self.L_, True), self.y_train_) # Line 3
return self
def predict(self, X, return_std=False, return_cov=False):
"""Predict using the Gaussian process regression model
We can also predict based on an unfitted model by using the GP prior.
In addition to the mean of the predictive distribution, also its
standard deviation (return_std=True) or covariance (return_cov=True).
Note that at most one of the two can be requested.
Parameters
----------
X : array-like, shape = (n_samples, n_features)
Query points where the GP is evaluated
return_std : bool, default: False
If True, the standard-deviation of the predictive distribution at
the query points is returned along with the mean.
return_cov : bool, default: False
If True, the covariance of the joint predictive distribution at
the query points is returned along with the mean
Returns
-------
y_mean : array, shape = (n_samples, [n_output_dims])
Mean of predictive distribution a query points
y_std : array, shape = (n_samples,), optional
Standard deviation of predictive distribution at query points.
Only returned when return_std is True.
y_cov : array, shape = (n_samples, n_samples), optional
Covariance of joint predictive distribution a query points.
Only returned when return_cov is True.
"""
if return_std and return_cov:
raise RuntimeError(
"Not returning standard deviation of predictions when "
"returning full covariance.")
X = check_array(X)
if not hasattr(self, "X_train_"): # Unfitted;predict based on GP prior
if self.kernel is None:
kernel = (C(1.0, constant_value_bounds="fixed") *
RBF(1.0, length_scale_bounds="fixed"))
else:
kernel = self.kernel
y_mean = np.zeros(X.shape[0])
if return_cov:
y_cov = kernel(X)
return y_mean, y_cov
elif return_std:
y_var = kernel.diag(X)
return y_mean, np.sqrt(y_var)
else:
return y_mean
else: # Predict based on GP posterior
K_trans = self.kernel_(X, self.X_train_)
y_mean = K_trans.dot(self.alpha_) # Line 4 (y_mean = f_star)
y_mean = self._y_train_mean + y_mean # undo normal.
if return_cov:
v = cho_solve((self.L_, True), K_trans.T) # Line 5
y_cov = self.kernel_(X) - K_trans.dot(v) # Line 6
return y_mean, y_cov
elif return_std:
# compute inverse K_inv of K based on its Cholesky
# decomposition L and its inverse L_inv
L_inv = solve_triangular(self.L_.T, np.eye(self.L_.shape[0]))
K_inv = L_inv.dot(L_inv.T)
# Compute variance of predictive distribution
y_var = self.kernel_.diag(X)
y_var -= np.einsum("ij,ij->i", np.dot(K_trans, K_inv), K_trans)
# Check if any of the variances is negative because of
# numerical issues. If yes: set the variance to 0.
y_var_negative = y_var < 0
if np.any(y_var_negative):
warnings.warn("Predicted variances smaller than 0. "
"Setting those variances to 0.")
y_var[y_var_negative] = 0.0
return y_mean, np.sqrt(y_var)
else:
return y_mean
def sample_y(self, X, n_samples=1, random_state=0):
"""Draw samples from Gaussian process and evaluate at X.
Parameters
----------
X : array-like, shape = (n_samples_X, n_features)
Query points where the GP samples are evaluated
n_samples : int, default: 1
The number of samples drawn from the Gaussian process
random_state : int, RandomState instance or None, optional (default=0)
If int, random_state is the seed used by the random number
generator; If RandomState instance, random_state is the
random number generator; If None, the random number
generator is the RandomState instance used by `np.random`.
Returns
-------
y_samples : array, shape = (n_samples_X, [n_output_dims], n_samples)
Values of n_samples samples drawn from Gaussian process and
evaluated at query points.
"""
rng = check_random_state(random_state)
y_mean, y_cov = self.predict(X, return_cov=True)
if y_mean.ndim == 1:
y_samples = rng.multivariate_normal(y_mean, y_cov, n_samples).T
else:
y_samples = \
[rng.multivariate_normal(y_mean[:, i], y_cov,
n_samples).T[:, np.newaxis]
for i in range(y_mean.shape[1])]
y_samples = np.hstack(y_samples)
return y_samples
def log_marginal_likelihood(self, theta=None, eval_gradient=False):
"""Returns log-marginal likelihood of theta for training data.
Parameters
----------
theta : array-like, shape = (n_kernel_params,) or None
Kernel hyperparameters for which the log-marginal likelihood is
evaluated. If None, the precomputed log_marginal_likelihood
of ``self.kernel_.theta`` is returned.
eval_gradient : bool, default: False
If True, the gradient of the log-marginal likelihood with respect
to the kernel hyperparameters at position theta is returned
additionally. If True, theta must not be None.
Returns
-------
log_likelihood : float
Log-marginal likelihood of theta for training data.
log_likelihood_gradient : array, shape = (n_kernel_params,), optional
Gradient of the log-marginal likelihood with respect to the kernel
hyperparameters at position theta.
Only returned when eval_gradient is True.
"""
if theta is None:
if eval_gradient:
raise ValueError(
"Gradient can only be evaluated for theta!=None")
return self.log_marginal_likelihood_value_
kernel = self.kernel_.clone_with_theta(theta)
if eval_gradient:
K, K_gradient = kernel(self.X_train_, eval_gradient=True)
else:
K = kernel(self.X_train_)
K[np.diag_indices_from(K)] += self.alpha
try:
L = cholesky(K, lower=True) # Line 2
except np.linalg.LinAlgError:
return (-np.inf, np.zeros_like(theta)) \
if eval_gradient else -np.inf
# Support multi-dimensional output of self.y_train_
y_train = self.y_train_
if y_train.ndim == 1:
y_train = y_train[:, np.newaxis]
alpha = cho_solve((L, True), y_train) # Line 3
# Compute log-likelihood (compare line 7)
log_likelihood_dims = -0.5 * np.einsum("ik,ik->k", y_train, alpha)
log_likelihood_dims -= np.log(np.diag(L)).sum()
log_likelihood_dims -= K.shape[0] / 2 * np.log(2 * np.pi)
log_likelihood = log_likelihood_dims.sum(-1) # sum over dimensions
if eval_gradient: # compare Equation 5.9 from GPML
tmp = np.einsum("ik,jk->ijk", alpha, alpha) # k: output-dimension
tmp -= cho_solve((L, True), np.eye(K.shape[0]))[:, :, np.newaxis]
# Compute "0.5 * trace(tmp.dot(K_gradient))" without
# constructing the full matrix tmp.dot(K_gradient) since only
# its diagonal is required
log_likelihood_gradient_dims = \
0.5 * np.einsum("ijl,ijk->kl", tmp, K_gradient)
log_likelihood_gradient = log_likelihood_gradient_dims.sum(-1)
if eval_gradient:
return log_likelihood, log_likelihood_gradient
else:
return log_likelihood
def _constrained_optimization(self, obj_func, initial_theta, bounds):
if self.optimizer == "fmin_l_bfgs_b":
theta_opt, func_min, convergence_dict = \
fmin_l_bfgs_b(obj_func, initial_theta, bounds=bounds)
if convergence_dict["warnflag"] != 0:
warnings.warn("fmin_l_bfgs_b terminated abnormally with the "
" state: %s" % convergence_dict)
elif callable(self.optimizer):
theta_opt, func_min = \
self.optimizer(obj_func, initial_theta, bounds=bounds)
else:
raise ValueError("Unknown optimizer %s." % self.optimizer)
return theta_opt, func_min
| mit |
walterreade/scikit-learn | sklearn/svm/classes.py | 34 | 40599 | import warnings
import numpy as np
from .base import _fit_liblinear, BaseSVC, BaseLibSVM
from ..base import BaseEstimator, RegressorMixin
from ..linear_model.base import LinearClassifierMixin, SparseCoefMixin, \
LinearModel
from ..feature_selection.from_model import _LearntSelectorMixin
from ..utils import check_X_y
from ..utils.validation import _num_samples
from ..utils.multiclass import check_classification_targets
class LinearSVC(BaseEstimator, LinearClassifierMixin,
_LearntSelectorMixin, SparseCoefMixin):
"""Linear Support Vector Classification.
Similar to SVC with parameter kernel='linear', but implemented in terms of
liblinear rather than libsvm, so it has more flexibility in the choice of
penalties and loss functions and should scale better to large numbers of
samples.
This class supports both dense and sparse input and the multiclass support
is handled according to a one-vs-the-rest scheme.
Read more in the :ref:`User Guide <svm_classification>`.
Parameters
----------
C : float, optional (default=1.0)
Penalty parameter C of the error term.
loss : string, 'hinge' or 'squared_hinge' (default='squared_hinge')
Specifies the loss function. 'hinge' is the standard SVM loss
(used e.g. by the SVC class) while 'squared_hinge' is the
square of the hinge loss.
penalty : string, 'l1' or 'l2' (default='l2')
Specifies the norm used in the penalization. The 'l2'
penalty is the standard used in SVC. The 'l1' leads to ``coef_``
vectors that are sparse.
dual : bool, (default=True)
Select the algorithm to either solve the dual or primal
optimization problem. Prefer dual=False when n_samples > n_features.
tol : float, optional (default=1e-4)
Tolerance for stopping criteria.
multi_class: string, 'ovr' or 'crammer_singer' (default='ovr')
Determines the multi-class strategy if `y` contains more than
two classes.
``"ovr"`` trains n_classes one-vs-rest classifiers, while ``"crammer_singer"``
optimizes a joint objective over all classes.
While `crammer_singer` is interesting from a theoretical perspective
as it is consistent, it is seldom used in practice as it rarely leads
to better accuracy and is more expensive to compute.
If ``"crammer_singer"`` is chosen, the options loss, penalty and dual will
be ignored.
fit_intercept : boolean, optional (default=True)
Whether to calculate the intercept for this model. If set
to false, no intercept will be used in calculations
(i.e. data is expected to be already centered).
intercept_scaling : float, optional (default=1)
When self.fit_intercept is True, instance vector x becomes
``[x, self.intercept_scaling]``,
i.e. a "synthetic" feature with constant value equals to
intercept_scaling is appended to the instance vector.
The intercept becomes intercept_scaling * synthetic feature weight
Note! the synthetic feature weight is subject to l1/l2 regularization
as all other features.
To lessen the effect of regularization on synthetic feature weight
(and therefore on the intercept) intercept_scaling has to be increased.
class_weight : {dict, 'balanced'}, optional
Set the parameter C of class i to ``class_weight[i]*C`` for
SVC. If not given, all classes are supposed to have
weight one.
The "balanced" mode uses the values of y to automatically adjust
weights inversely proportional to class frequencies in the input data
as ``n_samples / (n_classes * np.bincount(y))``
verbose : int, (default=0)
Enable verbose output. Note that this setting takes advantage of a
per-process runtime setting in liblinear that, if enabled, may not work
properly in a multithreaded context.
random_state : int seed, RandomState instance, or None (default=None)
The seed of the pseudo random number generator to use when
shuffling the data.
max_iter : int, (default=1000)
The maximum number of iterations to be run.
Attributes
----------
coef_ : array, shape = [n_features] if n_classes == 2 else [n_classes, n_features]
Weights assigned to the features (coefficients in the primal
problem). This is only available in the case of a linear kernel.
``coef_`` is a readonly property derived from ``raw_coef_`` that
follows the internal memory layout of liblinear.
intercept_ : array, shape = [1] if n_classes == 2 else [n_classes]
Constants in decision function.
Notes
-----
The underlying C implementation uses a random number generator to
select features when fitting the model. It is thus not uncommon
to have slightly different results for the same input data. If
that happens, try with a smaller ``tol`` parameter.
The underlying implementation, liblinear, uses a sparse internal
representation for the data that will incur a memory copy.
Predict output may not match that of standalone liblinear in certain
cases. See :ref:`differences from liblinear <liblinear_differences>`
in the narrative documentation.
References
----------
`LIBLINEAR: A Library for Large Linear Classification
<http://www.csie.ntu.edu.tw/~cjlin/liblinear/>`__
See also
--------
SVC
Implementation of Support Vector Machine classifier using libsvm:
the kernel can be non-linear but its SMO algorithm does not
scale to large number of samples as LinearSVC does.
Furthermore SVC multi-class mode is implemented using one
vs one scheme while LinearSVC uses one vs the rest. It is
possible to implement one vs the rest with SVC by using the
:class:`sklearn.multiclass.OneVsRestClassifier` wrapper.
Finally SVC can fit dense data without memory copy if the input
is C-contiguous. Sparse data will still incur memory copy though.
sklearn.linear_model.SGDClassifier
SGDClassifier can optimize the same cost function as LinearSVC
by adjusting the penalty and loss parameters. In addition it requires
less memory, allows incremental (online) learning, and implements
various loss functions and regularization regimes.
"""
def __init__(self, penalty='l2', loss='squared_hinge', dual=True, tol=1e-4,
C=1.0, multi_class='ovr', fit_intercept=True,
intercept_scaling=1, class_weight=None, verbose=0,
random_state=None, max_iter=1000):
self.dual = dual
self.tol = tol
self.C = C
self.multi_class = multi_class
self.fit_intercept = fit_intercept
self.intercept_scaling = intercept_scaling
self.class_weight = class_weight
self.verbose = verbose
self.random_state = random_state
self.max_iter = max_iter
self.penalty = penalty
self.loss = loss
def fit(self, X, y):
"""Fit the model according to the given training data.
Parameters
----------
X : {array-like, sparse matrix}, shape = [n_samples, n_features]
Training vector, where n_samples in the number of samples and
n_features is the number of features.
y : array-like, shape = [n_samples]
Target vector relative to X
Returns
-------
self : object
Returns self.
"""
# FIXME Remove l1/l2 support in 1.0 -----------------------------------
loss_l = self.loss.lower()
msg = ("loss='%s' has been deprecated in favor of "
"loss='%s' as of 0.16. Backward compatibility"
" for the loss='%s' will be removed in %s")
# FIXME change loss_l --> self.loss after 0.18
if loss_l in ('l1', 'l2'):
old_loss = self.loss
self.loss = {'l1': 'hinge', 'l2': 'squared_hinge'}.get(loss_l)
warnings.warn(msg % (old_loss, self.loss, old_loss, '1.0'),
DeprecationWarning)
# ---------------------------------------------------------------------
if self.C < 0:
raise ValueError("Penalty term must be positive; got (C=%r)"
% self.C)
X, y = check_X_y(X, y, accept_sparse='csr',
dtype=np.float64, order="C")
check_classification_targets(y)
self.classes_ = np.unique(y)
self.coef_, self.intercept_, self.n_iter_ = _fit_liblinear(
X, y, self.C, self.fit_intercept, self.intercept_scaling,
self.class_weight, self.penalty, self.dual, self.verbose,
self.max_iter, self.tol, self.random_state, self.multi_class,
self.loss)
if self.multi_class == "crammer_singer" and len(self.classes_) == 2:
self.coef_ = (self.coef_[1] - self.coef_[0]).reshape(1, -1)
if self.fit_intercept:
intercept = self.intercept_[1] - self.intercept_[0]
self.intercept_ = np.array([intercept])
return self
class LinearSVR(LinearModel, RegressorMixin):
"""Linear Support Vector Regression.
Similar to SVR with parameter kernel='linear', but implemented in terms of
liblinear rather than libsvm, so it has more flexibility in the choice of
penalties and loss functions and should scale better to large numbers of
samples.
This class supports both dense and sparse input.
Read more in the :ref:`User Guide <svm_regression>`.
Parameters
----------
C : float, optional (default=1.0)
Penalty parameter C of the error term. The penalty is a squared
l2 penalty. The bigger this parameter, the less regularization is used.
loss : string, 'epsilon_insensitive' or 'squared_epsilon_insensitive' (default='epsilon_insensitive')
Specifies the loss function. 'l1' is the epsilon-insensitive loss
(standard SVR) while 'l2' is the squared epsilon-insensitive loss.
epsilon : float, optional (default=0.1)
Epsilon parameter in the epsilon-insensitive loss function. Note
that the value of this parameter depends on the scale of the target
variable y. If unsure, set ``epsilon=0``.
dual : bool, (default=True)
Select the algorithm to either solve the dual or primal
optimization problem. Prefer dual=False when n_samples > n_features.
tol : float, optional (default=1e-4)
Tolerance for stopping criteria.
fit_intercept : boolean, optional (default=True)
Whether to calculate the intercept for this model. If set
to false, no intercept will be used in calculations
(i.e. data is expected to be already centered).
intercept_scaling : float, optional (default=1)
When self.fit_intercept is True, instance vector x becomes
[x, self.intercept_scaling],
i.e. a "synthetic" feature with constant value equals to
intercept_scaling is appended to the instance vector.
The intercept becomes intercept_scaling * synthetic feature weight
Note! the synthetic feature weight is subject to l1/l2 regularization
as all other features.
To lessen the effect of regularization on synthetic feature weight
(and therefore on the intercept) intercept_scaling has to be increased.
verbose : int, (default=0)
Enable verbose output. Note that this setting takes advantage of a
per-process runtime setting in liblinear that, if enabled, may not work
properly in a multithreaded context.
random_state : int seed, RandomState instance, or None (default=None)
The seed of the pseudo random number generator to use when
shuffling the data.
max_iter : int, (default=1000)
The maximum number of iterations to be run.
Attributes
----------
coef_ : array, shape = [n_features] if n_classes == 2 else [n_classes, n_features]
Weights assigned to the features (coefficients in the primal
problem). This is only available in the case of a linear kernel.
`coef_` is a readonly property derived from `raw_coef_` that
follows the internal memory layout of liblinear.
intercept_ : array, shape = [1] if n_classes == 2 else [n_classes]
Constants in decision function.
See also
--------
LinearSVC
Implementation of Support Vector Machine classifier using the
same library as this class (liblinear).
SVR
Implementation of Support Vector Machine regression using libsvm:
the kernel can be non-linear but its SMO algorithm does not
scale to large number of samples as LinearSVC does.
sklearn.linear_model.SGDRegressor
SGDRegressor can optimize the same cost function as LinearSVR
by adjusting the penalty and loss parameters. In addition it requires
less memory, allows incremental (online) learning, and implements
various loss functions and regularization regimes.
"""
def __init__(self, epsilon=0.0, tol=1e-4, C=1.0,
loss='epsilon_insensitive', fit_intercept=True,
intercept_scaling=1., dual=True, verbose=0,
random_state=None, max_iter=1000):
self.tol = tol
self.C = C
self.epsilon = epsilon
self.fit_intercept = fit_intercept
self.intercept_scaling = intercept_scaling
self.verbose = verbose
self.random_state = random_state
self.max_iter = max_iter
self.dual = dual
self.loss = loss
def fit(self, X, y):
"""Fit the model according to the given training data.
Parameters
----------
X : {array-like, sparse matrix}, shape = [n_samples, n_features]
Training vector, where n_samples in the number of samples and
n_features is the number of features.
y : array-like, shape = [n_samples]
Target vector relative to X
Returns
-------
self : object
Returns self.
"""
# FIXME Remove l1/l2 support in 1.0 -----------------------------------
loss_l = self.loss.lower()
msg = ("loss='%s' has been deprecated in favor of "
"loss='%s' as of 0.16. Backward compatibility"
" for the loss='%s' will be removed in %s")
# FIXME change loss_l --> self.loss after 0.18
if loss_l in ('l1', 'l2'):
old_loss = self.loss
self.loss = {'l1': 'epsilon_insensitive',
'l2': 'squared_epsilon_insensitive'
}.get(loss_l)
warnings.warn(msg % (old_loss, self.loss, old_loss, '1.0'),
DeprecationWarning)
# ---------------------------------------------------------------------
if self.C < 0:
raise ValueError("Penalty term must be positive; got (C=%r)"
% self.C)
X, y = check_X_y(X, y, accept_sparse='csr',
dtype=np.float64, order="C")
penalty = 'l2' # SVR only accepts l2 penalty
self.coef_, self.intercept_, self.n_iter_ = _fit_liblinear(
X, y, self.C, self.fit_intercept, self.intercept_scaling,
None, penalty, self.dual, self.verbose,
self.max_iter, self.tol, self.random_state, loss=self.loss,
epsilon=self.epsilon)
self.coef_ = self.coef_.ravel()
return self
class SVC(BaseSVC):
"""C-Support Vector Classification.
The implementation is based on libsvm. The fit time complexity
is more than quadratic with the number of samples which makes it hard
to scale to dataset with more than a couple of 10000 samples.
The multiclass support is handled according to a one-vs-one scheme.
For details on the precise mathematical formulation of the provided
kernel functions and how `gamma`, `coef0` and `degree` affect each
other, see the corresponding section in the narrative documentation:
:ref:`svm_kernels`.
Read more in the :ref:`User Guide <svm_classification>`.
Parameters
----------
C : float, optional (default=1.0)
Penalty parameter C of the error term.
kernel : string, optional (default='rbf')
Specifies the kernel type to be used in the algorithm.
It must be one of 'linear', 'poly', 'rbf', 'sigmoid', 'precomputed' or
a callable.
If none is given, 'rbf' will be used. If a callable is given it is
used to pre-compute the kernel matrix from data matrices; that matrix
should be an array of shape ``(n_samples, n_samples)``.
degree : int, optional (default=3)
Degree of the polynomial kernel function ('poly').
Ignored by all other kernels.
gamma : float, optional (default='auto')
Kernel coefficient for 'rbf', 'poly' and 'sigmoid'.
If gamma is 'auto' then 1/n_features will be used instead.
coef0 : float, optional (default=0.0)
Independent term in kernel function.
It is only significant in 'poly' and 'sigmoid'.
probability : boolean, optional (default=False)
Whether to enable probability estimates. This must be enabled prior
to calling `fit`, and will slow down that method.
shrinking : boolean, optional (default=True)
Whether to use the shrinking heuristic.
tol : float, optional (default=1e-3)
Tolerance for stopping criterion.
cache_size : float, optional
Specify the size of the kernel cache (in MB).
class_weight : {dict, 'balanced'}, optional
Set the parameter C of class i to class_weight[i]*C for
SVC. If not given, all classes are supposed to have
weight one.
The "balanced" mode uses the values of y to automatically adjust
weights inversely proportional to class frequencies in the input data
as ``n_samples / (n_classes * np.bincount(y))``
verbose : bool, default: False
Enable verbose output. Note that this setting takes advantage of a
per-process runtime setting in libsvm that, if enabled, may not work
properly in a multithreaded context.
max_iter : int, optional (default=-1)
Hard limit on iterations within solver, or -1 for no limit.
decision_function_shape : 'ovo', 'ovr' or None, default=None
Whether to return a one-vs-rest ('ovr') decision function of shape
(n_samples, n_classes) as all other classifiers, or the original
one-vs-one ('ovo') decision function of libsvm which has shape
(n_samples, n_classes * (n_classes - 1) / 2).
The default of None will currently behave as 'ovo' for backward
compatibility and raise a deprecation warning, but will change 'ovr'
in 0.18.
.. versionadded:: 0.17
*decision_function_shape='ovr'* is recommended.
.. versionchanged:: 0.17
Deprecated *decision_function_shape='ovo' and None*.
random_state : int seed, RandomState instance, or None (default)
The seed of the pseudo random number generator to use when
shuffling the data for probability estimation.
Attributes
----------
support_ : array-like, shape = [n_SV]
Indices of support vectors.
support_vectors_ : array-like, shape = [n_SV, n_features]
Support vectors.
n_support_ : array-like, dtype=int32, shape = [n_class]
Number of support vectors for each class.
dual_coef_ : array, shape = [n_class-1, n_SV]
Coefficients of the support vector in the decision function.
For multiclass, coefficient for all 1-vs-1 classifiers.
The layout of the coefficients in the multiclass case is somewhat
non-trivial. See the section about multi-class classification in the
SVM section of the User Guide for details.
coef_ : array, shape = [n_class-1, n_features]
Weights assigned to the features (coefficients in the primal
problem). This is only available in the case of a linear kernel.
`coef_` is a readonly property derived from `dual_coef_` and
`support_vectors_`.
intercept_ : array, shape = [n_class * (n_class-1) / 2]
Constants in decision function.
Examples
--------
>>> import numpy as np
>>> X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])
>>> y = np.array([1, 1, 2, 2])
>>> from sklearn.svm import SVC
>>> clf = SVC()
>>> clf.fit(X, y) #doctest: +NORMALIZE_WHITESPACE
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
decision_function_shape=None, degree=3, gamma='auto', kernel='rbf',
max_iter=-1, probability=False, random_state=None, shrinking=True,
tol=0.001, verbose=False)
>>> print(clf.predict([[-0.8, -1]]))
[1]
See also
--------
SVR
Support Vector Machine for Regression implemented using libsvm.
LinearSVC
Scalable Linear Support Vector Machine for classification
implemented using liblinear. Check the See also section of
LinearSVC for more comparison element.
"""
def __init__(self, C=1.0, kernel='rbf', degree=3, gamma='auto',
coef0=0.0, shrinking=True, probability=False,
tol=1e-3, cache_size=200, class_weight=None,
verbose=False, max_iter=-1, decision_function_shape=None,
random_state=None):
super(SVC, self).__init__(
impl='c_svc', kernel=kernel, degree=degree, gamma=gamma,
coef0=coef0, tol=tol, C=C, nu=0., shrinking=shrinking,
probability=probability, cache_size=cache_size,
class_weight=class_weight, verbose=verbose, max_iter=max_iter,
decision_function_shape=decision_function_shape,
random_state=random_state)
class NuSVC(BaseSVC):
"""Nu-Support Vector Classification.
Similar to SVC but uses a parameter to control the number of support
vectors.
The implementation is based on libsvm.
Read more in the :ref:`User Guide <svm_classification>`.
Parameters
----------
nu : float, optional (default=0.5)
An upper bound on the fraction of training errors and a lower
bound of the fraction of support vectors. Should be in the
interval (0, 1].
kernel : string, optional (default='rbf')
Specifies the kernel type to be used in the algorithm.
It must be one of 'linear', 'poly', 'rbf', 'sigmoid', 'precomputed' or
a callable.
If none is given, 'rbf' will be used. If a callable is given it is
used to precompute the kernel matrix.
degree : int, optional (default=3)
Degree of the polynomial kernel function ('poly').
Ignored by all other kernels.
gamma : float, optional (default='auto')
Kernel coefficient for 'rbf', 'poly' and 'sigmoid'.
If gamma is 'auto' then 1/n_features will be used instead.
coef0 : float, optional (default=0.0)
Independent term in kernel function.
It is only significant in 'poly' and 'sigmoid'.
probability : boolean, optional (default=False)
Whether to enable probability estimates. This must be enabled prior
to calling `fit`, and will slow down that method.
shrinking : boolean, optional (default=True)
Whether to use the shrinking heuristic.
tol : float, optional (default=1e-3)
Tolerance for stopping criterion.
cache_size : float, optional
Specify the size of the kernel cache (in MB).
class_weight : {dict, 'auto'}, optional
Set the parameter C of class i to class_weight[i]*C for
SVC. If not given, all classes are supposed to have
weight one. The 'auto' mode uses the values of y to
automatically adjust weights inversely proportional to
class frequencies.
verbose : bool, default: False
Enable verbose output. Note that this setting takes advantage of a
per-process runtime setting in libsvm that, if enabled, may not work
properly in a multithreaded context.
max_iter : int, optional (default=-1)
Hard limit on iterations within solver, or -1 for no limit.
decision_function_shape : 'ovo', 'ovr' or None, default=None
Whether to return a one-vs-rest ('ovr') decision function of shape
(n_samples, n_classes) as all other classifiers, or the original
one-vs-one ('ovo') decision function of libsvm which has shape
(n_samples, n_classes * (n_classes - 1) / 2).
The default of None will currently behave as 'ovo' for backward
compatibility and raise a deprecation warning, but will change 'ovr'
in 0.18.
.. versionadded:: 0.17
*decision_function_shape='ovr'* is recommended.
.. versionchanged:: 0.17
Deprecated *decision_function_shape='ovo' and None*.
random_state : int seed, RandomState instance, or None (default)
The seed of the pseudo random number generator to use when
shuffling the data for probability estimation.
Attributes
----------
support_ : array-like, shape = [n_SV]
Indices of support vectors.
support_vectors_ : array-like, shape = [n_SV, n_features]
Support vectors.
n_support_ : array-like, dtype=int32, shape = [n_class]
Number of support vectors for each class.
dual_coef_ : array, shape = [n_class-1, n_SV]
Coefficients of the support vector in the decision function.
For multiclass, coefficient for all 1-vs-1 classifiers.
The layout of the coefficients in the multiclass case is somewhat
non-trivial. See the section about multi-class classification in
the SVM section of the User Guide for details.
coef_ : array, shape = [n_class-1, n_features]
Weights assigned to the features (coefficients in the primal
problem). This is only available in the case of a linear kernel.
`coef_` is readonly property derived from `dual_coef_` and
`support_vectors_`.
intercept_ : array, shape = [n_class * (n_class-1) / 2]
Constants in decision function.
Examples
--------
>>> import numpy as np
>>> X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])
>>> y = np.array([1, 1, 2, 2])
>>> from sklearn.svm import NuSVC
>>> clf = NuSVC()
>>> clf.fit(X, y) #doctest: +NORMALIZE_WHITESPACE
NuSVC(cache_size=200, class_weight=None, coef0=0.0,
decision_function_shape=None, degree=3, gamma='auto', kernel='rbf',
max_iter=-1, nu=0.5, probability=False, random_state=None,
shrinking=True, tol=0.001, verbose=False)
>>> print(clf.predict([[-0.8, -1]]))
[1]
See also
--------
SVC
Support Vector Machine for classification using libsvm.
LinearSVC
Scalable linear Support Vector Machine for classification using
liblinear.
"""
def __init__(self, nu=0.5, kernel='rbf', degree=3, gamma='auto',
coef0=0.0, shrinking=True, probability=False,
tol=1e-3, cache_size=200, class_weight=None, verbose=False,
max_iter=-1, decision_function_shape=None, random_state=None):
super(NuSVC, self).__init__(
impl='nu_svc', kernel=kernel, degree=degree, gamma=gamma,
coef0=coef0, tol=tol, C=0., nu=nu, shrinking=shrinking,
probability=probability, cache_size=cache_size,
class_weight=class_weight, verbose=verbose, max_iter=max_iter,
decision_function_shape=decision_function_shape,
random_state=random_state)
class SVR(BaseLibSVM, RegressorMixin):
"""Epsilon-Support Vector Regression.
The free parameters in the model are C and epsilon.
The implementation is based on libsvm.
Read more in the :ref:`User Guide <svm_regression>`.
Parameters
----------
C : float, optional (default=1.0)
Penalty parameter C of the error term.
epsilon : float, optional (default=0.1)
Epsilon in the epsilon-SVR model. It specifies the epsilon-tube
within which no penalty is associated in the training loss function
with points predicted within a distance epsilon from the actual
value.
kernel : string, optional (default='rbf')
Specifies the kernel type to be used in the algorithm.
It must be one of 'linear', 'poly', 'rbf', 'sigmoid', 'precomputed' or
a callable.
If none is given, 'rbf' will be used. If a callable is given it is
used to precompute the kernel matrix.
degree : int, optional (default=3)
Degree of the polynomial kernel function ('poly').
Ignored by all other kernels.
gamma : float, optional (default='auto')
Kernel coefficient for 'rbf', 'poly' and 'sigmoid'.
If gamma is 'auto' then 1/n_features will be used instead.
coef0 : float, optional (default=0.0)
Independent term in kernel function.
It is only significant in 'poly' and 'sigmoid'.
shrinking : boolean, optional (default=True)
Whether to use the shrinking heuristic.
tol : float, optional (default=1e-3)
Tolerance for stopping criterion.
cache_size : float, optional
Specify the size of the kernel cache (in MB).
verbose : bool, default: False
Enable verbose output. Note that this setting takes advantage of a
per-process runtime setting in libsvm that, if enabled, may not work
properly in a multithreaded context.
max_iter : int, optional (default=-1)
Hard limit on iterations within solver, or -1 for no limit.
Attributes
----------
support_ : array-like, shape = [n_SV]
Indices of support vectors.
support_vectors_ : array-like, shape = [nSV, n_features]
Support vectors.
dual_coef_ : array, shape = [1, n_SV]
Coefficients of the support vector in the decision function.
coef_ : array, shape = [1, n_features]
Weights assigned to the features (coefficients in the primal
problem). This is only available in the case of a linear kernel.
`coef_` is readonly property derived from `dual_coef_` and
`support_vectors_`.
intercept_ : array, shape = [1]
Constants in decision function.
Examples
--------
>>> from sklearn.svm import SVR
>>> import numpy as np
>>> n_samples, n_features = 10, 5
>>> np.random.seed(0)
>>> y = np.random.randn(n_samples)
>>> X = np.random.randn(n_samples, n_features)
>>> clf = SVR(C=1.0, epsilon=0.2)
>>> clf.fit(X, y) #doctest: +NORMALIZE_WHITESPACE
SVR(C=1.0, cache_size=200, coef0=0.0, degree=3, epsilon=0.2, gamma='auto',
kernel='rbf', max_iter=-1, shrinking=True, tol=0.001, verbose=False)
See also
--------
NuSVR
Support Vector Machine for regression implemented using libsvm
using a parameter to control the number of support vectors.
LinearSVR
Scalable Linear Support Vector Machine for regression
implemented using liblinear.
"""
def __init__(self, kernel='rbf', degree=3, gamma='auto', coef0=0.0,
tol=1e-3, C=1.0, epsilon=0.1, shrinking=True,
cache_size=200, verbose=False, max_iter=-1):
super(SVR, self).__init__(
'epsilon_svr', kernel=kernel, degree=degree, gamma=gamma,
coef0=coef0, tol=tol, C=C, nu=0., epsilon=epsilon, verbose=verbose,
shrinking=shrinking, probability=False, cache_size=cache_size,
class_weight=None, max_iter=max_iter, random_state=None)
class NuSVR(BaseLibSVM, RegressorMixin):
"""Nu Support Vector Regression.
Similar to NuSVC, for regression, uses a parameter nu to control
the number of support vectors. However, unlike NuSVC, where nu
replaces C, here nu replaces the parameter epsilon of epsilon-SVR.
The implementation is based on libsvm.
Read more in the :ref:`User Guide <svm_regression>`.
Parameters
----------
C : float, optional (default=1.0)
Penalty parameter C of the error term.
nu : float, optional
An upper bound on the fraction of training errors and a lower bound of
the fraction of support vectors. Should be in the interval (0, 1]. By
default 0.5 will be taken.
kernel : string, optional (default='rbf')
Specifies the kernel type to be used in the algorithm.
It must be one of 'linear', 'poly', 'rbf', 'sigmoid', 'precomputed' or
a callable.
If none is given, 'rbf' will be used. If a callable is given it is
used to precompute the kernel matrix.
degree : int, optional (default=3)
Degree of the polynomial kernel function ('poly').
Ignored by all other kernels.
gamma : float, optional (default='auto')
Kernel coefficient for 'rbf', 'poly' and 'sigmoid'.
If gamma is 'auto' then 1/n_features will be used instead.
coef0 : float, optional (default=0.0)
Independent term in kernel function.
It is only significant in 'poly' and 'sigmoid'.
shrinking : boolean, optional (default=True)
Whether to use the shrinking heuristic.
tol : float, optional (default=1e-3)
Tolerance for stopping criterion.
cache_size : float, optional
Specify the size of the kernel cache (in MB).
verbose : bool, default: False
Enable verbose output. Note that this setting takes advantage of a
per-process runtime setting in libsvm that, if enabled, may not work
properly in a multithreaded context.
max_iter : int, optional (default=-1)
Hard limit on iterations within solver, or -1 for no limit.
Attributes
----------
support_ : array-like, shape = [n_SV]
Indices of support vectors.
support_vectors_ : array-like, shape = [nSV, n_features]
Support vectors.
dual_coef_ : array, shape = [1, n_SV]
Coefficients of the support vector in the decision function.
coef_ : array, shape = [1, n_features]
Weights assigned to the features (coefficients in the primal
problem). This is only available in the case of a linear kernel.
`coef_` is readonly property derived from `dual_coef_` and
`support_vectors_`.
intercept_ : array, shape = [1]
Constants in decision function.
Examples
--------
>>> from sklearn.svm import NuSVR
>>> import numpy as np
>>> n_samples, n_features = 10, 5
>>> np.random.seed(0)
>>> y = np.random.randn(n_samples)
>>> X = np.random.randn(n_samples, n_features)
>>> clf = NuSVR(C=1.0, nu=0.1)
>>> clf.fit(X, y) #doctest: +NORMALIZE_WHITESPACE
NuSVR(C=1.0, cache_size=200, coef0=0.0, degree=3, gamma='auto',
kernel='rbf', max_iter=-1, nu=0.1, shrinking=True, tol=0.001,
verbose=False)
See also
--------
NuSVC
Support Vector Machine for classification implemented with libsvm
with a parameter to control the number of support vectors.
SVR
epsilon Support Vector Machine for regression implemented with libsvm.
"""
def __init__(self, nu=0.5, C=1.0, kernel='rbf', degree=3,
gamma='auto', coef0=0.0, shrinking=True, tol=1e-3,
cache_size=200, verbose=False, max_iter=-1):
super(NuSVR, self).__init__(
'nu_svr', kernel=kernel, degree=degree, gamma=gamma, coef0=coef0,
tol=tol, C=C, nu=nu, epsilon=0., shrinking=shrinking,
probability=False, cache_size=cache_size, class_weight=None,
verbose=verbose, max_iter=max_iter, random_state=None)
class OneClassSVM(BaseLibSVM):
"""Unsupervised Outlier Detection.
Estimate the support of a high-dimensional distribution.
The implementation is based on libsvm.
Read more in the :ref:`User Guide <svm_outlier_detection>`.
Parameters
----------
kernel : string, optional (default='rbf')
Specifies the kernel type to be used in the algorithm.
It must be one of 'linear', 'poly', 'rbf', 'sigmoid', 'precomputed' or
a callable.
If none is given, 'rbf' will be used. If a callable is given it is
used to precompute the kernel matrix.
nu : float, optional
An upper bound on the fraction of training
errors and a lower bound of the fraction of support
vectors. Should be in the interval (0, 1]. By default 0.5
will be taken.
degree : int, optional (default=3)
Degree of the polynomial kernel function ('poly').
Ignored by all other kernels.
gamma : float, optional (default='auto')
Kernel coefficient for 'rbf', 'poly' and 'sigmoid'.
If gamma is 'auto' then 1/n_features will be used instead.
coef0 : float, optional (default=0.0)
Independent term in kernel function.
It is only significant in 'poly' and 'sigmoid'.
tol : float, optional
Tolerance for stopping criterion.
shrinking : boolean, optional
Whether to use the shrinking heuristic.
cache_size : float, optional
Specify the size of the kernel cache (in MB).
verbose : bool, default: False
Enable verbose output. Note that this setting takes advantage of a
per-process runtime setting in libsvm that, if enabled, may not work
properly in a multithreaded context.
max_iter : int, optional (default=-1)
Hard limit on iterations within solver, or -1 for no limit.
random_state : int seed, RandomState instance, or None (default)
The seed of the pseudo random number generator to use when
shuffling the data for probability estimation.
Attributes
----------
support_ : array-like, shape = [n_SV]
Indices of support vectors.
support_vectors_ : array-like, shape = [nSV, n_features]
Support vectors.
dual_coef_ : array, shape = [n_classes-1, n_SV]
Coefficients of the support vectors in the decision function.
coef_ : array, shape = [n_classes-1, n_features]
Weights assigned to the features (coefficients in the primal
problem). This is only available in the case of a linear kernel.
`coef_` is readonly property derived from `dual_coef_` and
`support_vectors_`
intercept_ : array, shape = [n_classes-1]
Constants in decision function.
"""
def __init__(self, kernel='rbf', degree=3, gamma='auto', coef0=0.0,
tol=1e-3, nu=0.5, shrinking=True, cache_size=200,
verbose=False, max_iter=-1, random_state=None):
super(OneClassSVM, self).__init__(
'one_class', kernel, degree, gamma, coef0, tol, 0., nu, 0.,
shrinking, False, cache_size, None, verbose, max_iter,
random_state)
def fit(self, X, y=None, sample_weight=None, **params):
"""
Detects the soft boundary of the set of samples X.
Parameters
----------
X : {array-like, sparse matrix}, shape (n_samples, n_features)
Set of samples, where n_samples is the number of samples and
n_features is the number of features.
sample_weight : array-like, shape (n_samples,)
Per-sample weights. Rescale C per sample. Higher weights
force the classifier to put more emphasis on these points.
Returns
-------
self : object
Returns self.
Notes
-----
If X is not a C-ordered contiguous array it is copied.
"""
super(OneClassSVM, self).fit(X, np.ones(_num_samples(X)), sample_weight=sample_weight,
**params)
return self
def decision_function(self, X):
"""Distance of the samples X to the separating hyperplane.
Parameters
----------
X : array-like, shape (n_samples, n_features)
Returns
-------
X : array-like, shape (n_samples,)
Returns the decision function of the samples.
"""
dec = self._decision_function(X)
return dec
| bsd-3-clause |
linkmax91/bitquant | web/home/ipython/examples/python-web.py | 1 | 2343 |
# coding: utf-8
# This is an example of registering a python web service. You can access the a service which
# is registered by name /python-web by http://localhost/app/python-web
# In[ ]:
#This creates a web service located off
#
#
# To shutdown the server you will need to
# restart the kernel
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get(self, *param):
self.write("Hello, world param=%s" % param[0])
import bitquantutils
bitquantutils.register_tornado_handler("/python-web", MainHandler)
# In[ ]:
#Create web service off of
# http://localhost/app/python-wsgi
def simple_app(environ, start_response):
status = "200 OK"
response_headers = [("Content-type", "text/plain")]
start_response(status, response_headers)
return [b"Hello world! with WSGI Handler\n"]
import bitquantutils
bitquantutils.register_wsgi("/python-wsgi", simple_app)
# In[ ]:
#Create web service off of
# http://localhost/app/python-web-html
from IPython.display import HTML
def html_response(input):
return """<table>
<tr>
<th>Header 1</th>
<th>Header 2</th>
</tr>
<tr>
<td>row 1, cell 1</td>
<td>row 1, cell 2</td>
</tr>
<tr>
<td>row 2, cell 1</td>
<td>row 2, cell 2</td>
</tr>
</table>"""
HTML(html_response(None))
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write(html_response(None))
import bitquantutils
bitquantutils.register_tornado_handler("/python-web-html", MainHandler)
# In[ ]:
#Create web service off of
# http://localhost/app/python-web-image
get_ipython().magic('matplotlib inline')
def image_response(input):
import matplotlib
import matplotlib.pyplot as plt
import io
from matplotlib import numpy as np
x = np.arange(0,np.pi*3,.1)
y = np.sin(x)
fig = plt.figure()
plt.plot(x,y)
imgdata = io.StringIO()
fig.savefig(imgdata, format='svg')
return imgdata.getvalue()
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write(image_response(None))
self.set_header("Content-type", "image/svg")
import bitquantutils
bitquantutils.register_tornado_handler("/python-web-image", MainHandler)
# In[ ]:
import bitquantutils
bitquantutils.start_loop()
# In[ ]:
bitquantutils.unregister_all()
# In[ ]:
| apache-2.0 |
Drob-AI/The-Observer | src/mod_suggest/tree_trainer.py | 1 | 4804 | import random
import numpy as np
from sklearn import tree
from sklearn import neighbors
from sklearn import svm
from sklearn import grid_search
from sklearn.metrics import accuracy_score
from sklearn.grid_search import GridSearchCV
from sklearn import cross_validation
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import mean_squared_error
def split_sets(dataset, test_set_len):
test_set = []
original_dataset_len = len(dataset)
dataset = list(dataset)
while(len(test_set) < original_dataset_len * test_set_len):
index = random.randint(0, len(dataset) - 1)
test_set.append(dataset[index])
del dataset[index]
return ( test_set, dataset)
def split_train_result_set(set, feature_index):
transponed = np.array(set).T
results_set = transponed[feature_index]
transponed = list(transponed)
del transponed[feature_index]
x_set = np.array(transponed).T
results_set = results_set.T
return(x_set, results_set)
def train_classifier_tree(dataset, feature_index, stats):
# print(dataset, feature_index)
test_set, train_set = split_sets(dataset, 0.1)
x_train, y_train = split_train_result_set(train_set, feature_index)
x_train_test, y_train_test = split_train_result_set(test_set, feature_index)
# if( stats[feature_index]['type'] == 'string'):
clf = tree.DecisionTreeClassifier()
clf = clf.fit(x_train, y_train)
print(accuracy_score(clf.predict(x_train_test), y_train_test))
print(len(test_set), len(train_set))
# else:
# clf = tree.DecisionTreeClassifier()
# print(x_train, y_train)
# clf = clf.fit(x_train, y_train)
# print("MSE", mean_squared_error(clf.predict(x_train_test), y_train_test))
# print(len(test_set), len(train_set))
def train_classifier_tree2(dataset, feature_index, stats):
# print(dataset, feature_index)
test_set, train_set = split_sets(dataset, 0.1)
x_train, y_train = split_train_result_set(train_set, feature_index)
x_train_test, y_train_test = split_train_result_set(test_set, feature_index)
n_estimators=[100, 180]
min_samples_split=[2, 10]
clf = RandomForestClassifier()
# clf = tree.DecisionTreeClassifier()
# clf = clf.fit(x_train, y_train)
nFolds = 5
param_grid = dict(n_estimators=n_estimators, min_samples_split=min_samples_split)
# param_grid = dict(max_depth=[10, 11, 12, 15],)
cv = cross_validation.StratifiedKFold(y_train, nFolds)
grid = GridSearchCV(clf, param_grid=param_grid,cv=cv)
grid.fit(x_train, y_train)
print(accuracy_score(grid.predict(x_train_test), y_train_test))
print(len(test_set), len(train_set))
def train_knn(dataset, feature_index, stats):
test_set, train_set = split_sets(dataset, 0.1)
x_train, y_train = split_train_result_set(train_set, feature_index)
x_train_test, y_train_test = split_train_result_set(test_set, feature_index)
knn = neighbors.KNeighborsClassifier()
knn = knn.fit(x_train, y_train)
print(accuracy_score(knn.predict(x_train_test), y_train_test))
print(len(test_set), len(train_set))
def train_knn2(dataset, feature_index, stats):
test_set, train_set = split_sets(dataset, 0.1)
x_train, y_train = split_train_result_set(train_set, feature_index)
x_train_test, y_train_test = split_train_result_set(test_set, feature_index)
nFolds = 4
metrics = ['minkowski','euclidean','manhattan']
weights = ['uniform','distance']
numNeighbors = np.arange(5, 10)
param_grid = dict(metric=metrics,weights=weights,n_neighbors=numNeighbors)
cv = cross_validation.StratifiedKFold(y_train, nFolds)
grid = GridSearchCV(neighbors.KNeighborsClassifier(), param_grid=param_grid,cv=cv)
grid.fit(x_train, y_train)
print(accuracy_score(grid.predict(x_train_test), y_train_test))
def train_classifier_svm(dataset, feature_index, stats):
test_set, train_set = split_sets(dataset, 0.1)
x_train, y_train = split_train_result_set(train_set, feature_index)
x_train_test, y_train_test = split_train_result_set(test_set, feature_index)
clf = svm.SVC()
clf = clf.fit(x_train, y_train)
print(accuracy_score(clf.predict(x_train_test), y_train_test))
print(len(test_set), len(train_set))
def train_classifier_svm2(dataset, feature_index, stats):
test_set, train_set = split_sets(dataset, 0.1)
x_train, y_train = split_train_result_set(train_set, feature_index)
x_train_test, y_train_test = split_train_result_set(test_set, feature_index)
param_grid = [{'C': [1, 10, 100, 1000], 'gamma': [0.001, 0.0001], 'kernel': ['rbf']}]
grid = GridSearchCV(svm.SVC(), param_grid=param_grid)
grid.fit(x_train, y_train)
print(accuracy_score(grid.predict(x_train_test), y_train_test)) | mit |
jbedorf/tensorflow | tensorflow/contrib/metrics/python/kernel_tests/histogram_ops_test.py | 24 | 9587 | # Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for histogram_ops."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
from tensorflow.contrib.metrics.python.ops import histogram_ops
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import variables
from tensorflow.python.platform import test
class Strict1dCumsumTest(test.TestCase):
"""Test this private function."""
def test_empty_tensor_returns_empty(self):
with self.cached_session():
tensor = constant_op.constant([])
result = histogram_ops._strict_1d_cumsum(tensor, 0)
expected = constant_op.constant([])
np.testing.assert_array_equal(expected.eval(), result.eval())
def test_length_1_tensor_works(self):
with self.cached_session():
tensor = constant_op.constant([3], dtype=dtypes.float32)
result = histogram_ops._strict_1d_cumsum(tensor, 1)
expected = constant_op.constant([3], dtype=dtypes.float32)
np.testing.assert_array_equal(expected.eval(), result.eval())
def test_length_3_tensor_works(self):
with self.cached_session():
tensor = constant_op.constant([1, 2, 3], dtype=dtypes.float32)
result = histogram_ops._strict_1d_cumsum(tensor, 3)
expected = constant_op.constant([1, 3, 6], dtype=dtypes.float32)
np.testing.assert_array_equal(expected.eval(), result.eval())
class AUCUsingHistogramTest(test.TestCase):
def setUp(self):
self.rng = np.random.RandomState(0)
def test_empty_labels_and_scores_gives_nan_auc(self):
with self.cached_session():
labels = constant_op.constant([], shape=[0], dtype=dtypes.bool)
scores = constant_op.constant([], shape=[0], dtype=dtypes.float32)
score_range = [0, 1.]
auc, update_op = histogram_ops.auc_using_histogram(labels, scores,
score_range)
variables.local_variables_initializer().run()
update_op.run()
self.assertTrue(np.isnan(auc.eval()))
def test_perfect_scores_gives_auc_1(self):
self._check_auc(
nbins=100,
desired_auc=1.0,
score_range=[0, 1.],
num_records=50,
frac_true=0.5,
atol=0.05,
num_updates=1)
def test_terrible_scores_gives_auc_0(self):
self._check_auc(
nbins=100,
desired_auc=0.0,
score_range=[0, 1.],
num_records=50,
frac_true=0.5,
atol=0.05,
num_updates=1)
def test_many_common_conditions(self):
for nbins in [50]:
for desired_auc in [0.3, 0.5, 0.8]:
for score_range in [[-1, 1], [-10, 0]]:
for frac_true in [0.3, 0.8]:
# Tests pass with atol = 0.03. Moved up to 0.05 to avoid flakes.
self._check_auc(
nbins=nbins,
desired_auc=desired_auc,
score_range=score_range,
num_records=100,
frac_true=frac_true,
atol=0.05,
num_updates=50)
def test_large_class_imbalance_still_ok(self):
# With probability frac_true ** num_records, each batch contains only True
# records. In this case, ~ 95%.
# Tests pass with atol = 0.02. Increased to 0.05 to avoid flakes.
self._check_auc(
nbins=100,
desired_auc=0.8,
score_range=[-1, 1.],
num_records=10,
frac_true=0.995,
atol=0.05,
num_updates=1000)
def test_super_accuracy_with_many_bins_and_records(self):
# Test passes with atol = 0.0005. Increased atol to avoid flakes.
self._check_auc(
nbins=1000,
desired_auc=0.75,
score_range=[0, 1.],
num_records=1000,
frac_true=0.5,
atol=0.005,
num_updates=100)
def _check_auc(self,
nbins=100,
desired_auc=0.75,
score_range=None,
num_records=50,
frac_true=0.5,
atol=0.05,
num_updates=10):
"""Check auc accuracy against synthetic data.
Args:
nbins: nbins arg from contrib.metrics.auc_using_histogram.
desired_auc: Number in [0, 1]. The desired auc for synthetic data.
score_range: 2-tuple, (low, high), giving the range of the resultant
scores. Defaults to [0, 1.].
num_records: Positive integer. The number of records to return.
frac_true: Number in (0, 1). Expected fraction of resultant labels that
will be True. This is just in expectation...more or less may actually
be True.
atol: Absolute tolerance for final AUC estimate.
num_updates: Update internal histograms this many times, each with a new
batch of synthetic data, before computing final AUC.
Raises:
AssertionError: If resultant AUC is not within atol of theoretical AUC
from synthetic data.
"""
score_range = [0, 1.] or score_range
with self.cached_session():
labels = array_ops.placeholder(dtypes.bool, shape=[num_records])
scores = array_ops.placeholder(dtypes.float32, shape=[num_records])
auc, update_op = histogram_ops.auc_using_histogram(
labels, scores, score_range, nbins=nbins)
variables.local_variables_initializer().run()
# Updates, then extract auc.
for _ in range(num_updates):
labels_a, scores_a = synthetic_data(desired_auc, score_range,
num_records, self.rng, frac_true)
update_op.run(feed_dict={labels: labels_a, scores: scores_a})
labels_a, scores_a = synthetic_data(desired_auc, score_range, num_records,
self.rng, frac_true)
# Fetch current auc, and verify that fetching again doesn't change it.
auc_eval = auc.eval()
self.assertAlmostEqual(auc_eval, auc.eval(), places=5)
msg = ('nbins: %s, desired_auc: %s, score_range: %s, '
'num_records: %s, frac_true: %s, num_updates: %s') % (nbins,
desired_auc,
score_range,
num_records,
frac_true,
num_updates)
np.testing.assert_allclose(desired_auc, auc_eval, atol=atol, err_msg=msg)
def synthetic_data(desired_auc, score_range, num_records, rng, frac_true):
"""Create synthetic boolean_labels and scores with adjustable auc.
Args:
desired_auc: Number in [0, 1], the theoretical AUC of resultant data.
score_range: 2-tuple, (low, high), giving the range of the resultant scores
num_records: Positive integer. The number of records to return.
rng: Initialized np.random.RandomState random number generator
frac_true: Number in (0, 1). Expected fraction of resultant labels that
will be True. This is just in expectation...more or less may actually be
True.
Returns:
boolean_labels: np.array, dtype=bool.
scores: np.array, dtype=np.float32
"""
# We prove here why the method (below) for computing AUC works. Of course we
# also checked this against sklearn.metrics.roc_auc_curve.
#
# First do this for score_range = [0, 1], then rescale.
# WLOG assume AUC >= 0.5, otherwise we will solve for AUC >= 0.5 then swap
# the labels.
# So for AUC in [0, 1] we create False and True labels
# and corresponding scores drawn from:
# F ~ U[0, 1], T ~ U[x, 1]
# We have,
# AUC
# = P[T > F]
# = P[T > F | F < x] P[F < x] + P[T > F | F > x] P[F > x]
# = (1 * x) + (0.5 * (1 - x)).
# Inverting, we have:
# x = 2 * AUC - 1, when AUC >= 0.5.
assert 0 <= desired_auc <= 1
assert 0 < frac_true < 1
if desired_auc < 0.5:
flip_labels = True
desired_auc = 1 - desired_auc
frac_true = 1 - frac_true
else:
flip_labels = False
x = 2 * desired_auc - 1
labels = rng.binomial(1, frac_true, size=num_records).astype(bool)
num_true = labels.sum()
num_false = num_records - labels.sum()
# Draw F ~ U[0, 1], and T ~ U[x, 1]
false_scores = rng.rand(num_false)
true_scores = x + rng.rand(num_true) * (1 - x)
# Reshape [0, 1] to score_range.
def reshape(scores):
return score_range[0] + scores * (score_range[1] - score_range[0])
false_scores = reshape(false_scores)
true_scores = reshape(true_scores)
# Place into one array corresponding with the labels.
scores = np.nan * np.ones(num_records, dtype=np.float32)
scores[labels] = true_scores
scores[~labels] = false_scores
if flip_labels:
labels = ~labels
return labels, scores
if __name__ == '__main__':
test.main()
| apache-2.0 |
wathen/PhD | MHD/FEniCS/MHD/CG/PicardIter_Direct/DecoupleTest/MHDnewcastle.py | 1 | 11326 | #!/usr/bin/python
# interpolate scalar gradient onto nedelec space
from dolfin import *
import petsc4py
import sys
petsc4py.init(sys.argv)
from petsc4py import PETSc
Print = PETSc.Sys.Print
# from MatrixOperations import *
import numpy as np
import matplotlib.pylab as plt
import PETScIO as IO
import common
import scipy
import scipy.io
import time as t
import BiLinear as forms
import DirectOperations as Iter
import MatrixOperations as MO
import CheckPetsc4py as CP
import ExactSol
# locals()
#Modules([forms,Iter,MO,CP,ExactSol,IO,common])
#ff
m = 5
Type = ['Full','MD','CD']
errL2u =np.zeros((m-1,1))
errH1u =np.zeros((m-1,1))
errL2p =np.zeros((m-1,1))
errL2b =np.zeros((m-1,1))
errCurlb =np.zeros((m-1,1))
errL2r =np.zeros((m-1,1))
errH1r =np.zeros((m-1,1))
l2uorder = np.zeros((m-1,1))
H1uorder =np.zeros((m-1,1))
l2porder = np.zeros((m-1,1))
l2border = np.zeros((m-1,1))
Curlborder =np.zeros((m-1,1))
l2rorder = np.zeros((m-1,1))
H1rorder = np.zeros((m-1,1))
NN = np.zeros((m-1,1))
DoF = np.zeros((m-1,1))
Velocitydim = np.zeros((m-1,1))
Magneticdim = np.zeros((m-1,1))
Pressuredim = np.zeros((m-1,1))
Lagrangedim = np.zeros((m-1,1))
Wdim = np.zeros((m-1,1))
iterations = np.zeros((m-1,1))
SolTime = np.zeros((m-1,1))
udiv = np.zeros((m-1,1))
MU = np.zeros((m-1,1))
level = np.zeros((m-1,1))
nn = 2
mm = 4
MUsave = np.zeros((mm*3,1))
MUit = np.zeros((m-1,mm*3))
print MUit[0,0]
dim = 2
ShowResultPlots = 'yes'
split = 'Linear'
MU[0]= 1e0
R = 010.0
jj = 0
for yy in xrange(1,mm+1):
MU =(R*10**(-yy))
print "++++++++",MU
for ii in xrange(0,3):
jj += 1
MUsave[jj-1] = MU
for xx in xrange(1,m):
IterType = Type[ii]
print xx
level[xx-1] = xx+2
nn = 2**(level[xx-1])
print "==================================",IterType
# Create mesh and define function space
nn = int(nn)
NN[xx-1] = nn/2
parameters["form_compiler"]["quadrature_degree"] = -1
mesh = UnitSquareMesh(nn,nn)
order = 2
parameters['reorder_dofs_serial'] = False
Velocity = VectorFunctionSpace(mesh, "CG", order)
Pressure = FunctionSpace(mesh, "CG", order-1)
Magnetic = FunctionSpace(mesh, "N1curl", order)
Lagrange = FunctionSpace(mesh, "CG", order)
W = MixedFunctionSpace([Velocity,Pressure,Magnetic,Lagrange])
# W = Velocity*Pressure*Magnetic*Lagrange
Velocitydim[xx-1] = Velocity.dim()
Pressuredim[xx-1] = Pressure.dim()
Magneticdim[xx-1] = Magnetic.dim()
Lagrangedim[xx-1] = Lagrange.dim()
Wdim[xx-1] = W.dim()
print "\n\nW: ",Wdim[xx-1],"Velocity: ",Velocitydim[xx-1],"Pressure: ",Pressuredim[xx-1],"Magnetic: ",Magneticdim[xx-1],"Lagrange: ",Lagrangedim[xx-1],"\n\n"
dim = [Velocity.dim(), Pressure.dim(), Magnetic.dim(), Lagrange.dim()]
def boundary(x, on_boundary):
return on_boundary
u0, p0,b0, r0, Laplacian, Advection, gradPres,CurlCurl, gradR, NS_Couple, M_Couple = ExactSol.MHD2D(4,1)
# plot(interpolate(u0,Velocity))
p0 = interpolate(p0,Pressure)
p0.vector()[:] -= np.max(p0.vector().array() )/2
# plot(interpolate(p0,Pressure))
bcu = DirichletBC(W.sub(0),u0, boundary)
bcb = DirichletBC(W.sub(2),b0, boundary)
bcr = DirichletBC(W.sub(3),r0, boundary)
# bc = [u0,p0,b0,r0]
bcs = [bcu,bcb,bcr]
FSpaces = [Velocity,Pressure,Magnetic,Lagrange]
(u, p, b, r) = TrialFunctions(W)
(v, q, c,s ) = TestFunctions(W)
kappa = 1.0
Mu_m =10.0
# MU = 1.0
print "================================",MU
F_NS = -MU*Laplacian + Advection + gradPres - kappa*NS_Couple
F_M = Mu_m*kappa*CurlCurl + gradR - kappa*M_Couple
params = [kappa,Mu_m,MU]
u_k,p_k,b_k,r_k = common.InitialGuess(FSpaces,[u0,p0,b0,r0],[F_NS,F_M],params,Neumann=Expression(("0","0")),options ="New")
# plot(u_k)
VelPres = Velocitydim[xx-1]+Pressuredim[xx-1]
# t.sleep(10)
ones = Function(Pressure)
ones.vector()[:]=(0*ones.vector().array()+1)
pConst = -assemble(p_k*dx)/assemble(ones*dx)
p_k.vector()[:] += pConst
x = Iter.u_prev(u_k,p_k,b_k,r_k)
# plot(b_k)
ns,maxwell,CoupleTerm,Lmaxwell,Lns = forms.MHD2D(mesh, W, F_M, F_NS, u_k, b_k, params, IterType)
RHSform = forms.PicardRHS(mesh, W, u_k, p_k, b_k, r_k, params)
bcu = DirichletBC(W.sub(0),Expression(("0.0","0.0")), boundary)
bcb = DirichletBC(W.sub(2),Expression(("0.0","0.0")), boundary)
bcr = DirichletBC(W.sub(3),Expression(("0.0")), boundary)
bcs = [bcu,bcb,bcr]
eps = 1.0 # error measure ||u-u_k||
tol = 1.0E-5 # tolerance
iter = 0 # iteration counter
maxiter = 40 # max no of iterations allowed
SolutionTime = 0
outer = 0
parameters['linear_algebra_backend'] = 'uBLAS'
p = forms.Preconditioner(mesh,W,u_k, b_k,params,IterType)
# PP,Pb = assemble_system(p, Lns,bcs)
if IterType == "CD":
AA, bb = assemble_system(maxwell+ns+CoupleTerm, (Lmaxwell + Lns) - RHSform, bcs)
A,b,u = Iter.RemoveRowCol(AA,bb,VelPres)
while eps > tol and iter < maxiter:
iter += 1
if IterType == "CD":
bb = assemble((Lmaxwell + Lns) - RHSform)
for bc in bcs:
bc.apply(bb)
A,b,u = Iter.RemoveRowCol(AA,bb,VelPres)
else:
AA, bb = assemble_system(maxwell+ns+CoupleTerm, (Lmaxwell + Lns) - RHSform, bcs)
A,b,u = Iter.RemoveRowCol(AA,bb,VelPres)
ksp = PETSc.KSP().create()
pc = ksp.getPC()#.PC().create()
# P = MO.shift(A,0.000001)
ksp.setOperators(A )
del A
OptDB = PETSc.Options()
OptDB["ksp_type"] = "preonly"
OptDB["pc_type"] = "lu"
OptDB["pc_factor_mat_ordering_type"] = "rcm"
OptDB["pc_factor_mat_solver_package"] = "mumps"
# OptDB["pc_factor_shift_amount"] = 2
ksp.setFromOptions()
tic()
ksp.solve(b, u)
time = toc()
print time
SolutionTime = SolutionTime +time
del ksp, pc
u, p, b, r, eps= Iter.PicardToleranceDecouple(u,x,FSpaces,dim,"2",iter)
p.vector()[:] += - assemble(p*dx)/assemble(ones*dx)
u_k.assign(u)
p_k.assign(p)
b_k.assign(b)
r_k.assign(r)
# plot(u_k)
# plot(p_k)
uOld= np.concatenate((u_k.vector().array(),p_k.vector().array(),b_k.vector().array(),r_k.vector().array()), axis=0)
x = Iter.u_prev(u_k,p_k,b_k,r_k)
if eps > 1e10:
iter = 0
break
# u_k,b_k,epsu,epsb=Iter.PicardTolerance(x,u_k,b_k,FSpaces,dim,"inf",iter)
MUit[xx-1,jj-1]= iter
# SolTime[xx-1] = SolutionTime/iter
ue =u0
pe = p0
be = b0
re = r0
ExactSolution = [ue,pe,be,re]
# errL2u[xx-1], errH1u[xx-1], errL2p[xx-1], errL2b[xx-1], errCurlb[xx-1], errL2r[xx-1], errH1r[xx-1] = Iter.Errors(x,mesh,FSpaces,ExactSolution,order,dim)
# if xx == 1:
# l2uorder[xx-1] = 0
# else:
# l2uorder[xx-1] = np.abs(np.log2(errL2u[xx-2]/errL2u[xx-1]))
# H1uorder[xx-1] = np.abs(np.log2(errH1u[xx-2]/errH1u[xx-1]))
# l2porder[xx-1] = np.abs(np.log2(errL2p[xx-2]/errL2p[xx-1]))
# l2border[xx-1] = np.abs(np.log2(errL2b[xx-2]/errL2b[xx-1]))
# Curlborder[xx-1] = np.abs(np.log2(errCurlb[xx-2]/errCurlb[xx-1]))
# l2rorder[xx-1] = np.abs(np.log2(errL2r[xx-2]/errL2r[xx-1]))
# H1rorder[xx-1] = np.abs(np.log2(errH1r[xx-2]/errH1r[xx-1]))
print MUit
import pandas as pd
LatexTitles = ["l","DoF"]
for x in xrange(1,mm+1):
LatexTitles.extend(["it","it","it"])
LatexValues = np.concatenate((level,Wdim,MUit), axis=1)
title = np.concatenate((np.array([[0,0]]),MUsave.T),axis=1)
MU = ["0","0"]
for x in xrange(1,mm+1):
MU.extend(["Full","MD","CD"])
LatexValues = np.vstack((title,LatexValues))
LatexTable = pd.DataFrame(LatexValues, columns = LatexTitles)
print LatexTable.to_latex()
# LatexTitles = ["l","DoFu","Dofp","V-L2","L2-order","V-H1","H1-order","P-L2","PL2-order"]
# LatexValues = np.concatenate((level,Velocitydim,Pressuredim,errL2u,l2uorder,errH1u,H1uorder,errL2p,l2porder), axis=1)
# LatexTable = pd.DataFrame(LatexValues, columns = LatexTitles)
# pd.set_option('precision',3)
# LatexTable = MO.PandasFormat(LatexTable,"V-L2","%2.4e")
# LatexTable = MO.PandasFormat(LatexTable,'V-H1',"%2.4e")
# LatexTable = MO.PandasFormat(LatexTable,"H1-order","%1.2f")
# LatexTable = MO.PandasFormat(LatexTable,'L2-order',"%1.2f")
# LatexTable = MO.PandasFormat(LatexTable,"P-L2","%2.4e")
# LatexTable = MO.PandasFormat(LatexTable,'PL2-order',"%1.2f")
# print LatexTable.to_latex()
# print "\n\n Magnetic convergence"
# MagneticTitles = ["l","B DoF","R DoF","B-L2","L2-order","B-Curl","HCurl-order"]
# MagneticValues = np.concatenate((level,Magneticdim,Lagrangedim,errL2b,l2border,errCurlb,Curlborder),axis=1)
# MagneticTable= pd.DataFrame(MagneticValues, columns = MagneticTitles)
# pd.set_option('precision',3)
# MagneticTable = MO.PandasFormat(MagneticTable,"B-Curl","%2.4e")
# MagneticTable = MO.PandasFormat(MagneticTable,'B-L2',"%2.4e")
# MagneticTable = MO.PandasFormat(MagneticTable,"L2-order","%1.2f")
# MagneticTable = MO.PandasFormat(MagneticTable,'HCurl-order',"%1.2f")
# print MagneticTable.to_latex()
# print "\n\n Lagrange convergence"
# LagrangeTitles = ["l","B DoF","R DoF","R-L2","L2-order","R-H1","H1-order"]
# LagrangeValues = np.concatenate((level,Magneticdim,Lagrangedim,errL2r,l2rorder,errH1r,H1rorder),axis=1)
# LagrangeTable= pd.DataFrame(LagrangeValues, columns = LagrangeTitles)
# pd.set_option('precision',3)
# LagrangeTable = MO.PandasFormat(LagrangeTable,"R-L2","%2.4e")
# LagrangeTable = MO.PandasFormat(LagrangeTable,'R-H1',"%2.4e")
# LagrangeTable = MO.PandasFormat(LagrangeTable,"H1-order","%1.2f")
# LagrangeTable = MO.PandasFormat(LagrangeTable,'L2-order',"%1.2f")
# print LagrangeTable.to_latex()
# # # if (ShowResultPlots == 'yes'):
# plot(u_k)
# plot(b_k)
# plot(r_k)
# plot(p_k)
# # # plot(ba)
# plot(interpolate(p0,Pressure))
# # plot(ra)
# plot(interpolate(re,Lagrange))
# interactive()
interactive()
def ModuleCheck():
modulenames = set(sys.modules)&set(globals())
print modulenames
ModuleCheck()
| mit |
Srisai85/scikit-learn | sklearn/tests/test_cross_validation.py | 27 | 41664 | """Test the cross_validation module"""
from __future__ import division
import warnings
import numpy as np
from scipy.sparse import coo_matrix
from scipy import stats
from sklearn.utils.testing import assert_true
from sklearn.utils.testing import assert_false
from sklearn.utils.testing import assert_equal
from sklearn.utils.testing import assert_almost_equal
from sklearn.utils.testing import assert_raises
from sklearn.utils.testing import assert_greater
from sklearn.utils.testing import assert_less
from sklearn.utils.testing import assert_not_equal
from sklearn.utils.testing import assert_array_almost_equal
from sklearn.utils.testing import assert_array_equal
from sklearn.utils.testing import assert_warns_message
from sklearn.utils.testing import ignore_warnings
from sklearn.utils.mocking import CheckingClassifier, MockDataFrame
from sklearn import cross_validation as cval
from sklearn.datasets import make_regression
from sklearn.datasets import load_boston
from sklearn.datasets import load_digits
from sklearn.datasets import load_iris
from sklearn.metrics import explained_variance_score
from sklearn.metrics import make_scorer
from sklearn.metrics import precision_score
from sklearn.externals import six
from sklearn.externals.six.moves import zip
from sklearn.linear_model import Ridge
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.cluster import KMeans
from sklearn.preprocessing import Imputer
from sklearn.pipeline import Pipeline
class MockClassifier(object):
"""Dummy classifier to test the cross-validation"""
def __init__(self, a=0, allow_nd=False):
self.a = a
self.allow_nd = allow_nd
def fit(self, X, Y=None, sample_weight=None, class_prior=None,
sparse_sample_weight=None, sparse_param=None, dummy_int=None,
dummy_str=None, dummy_obj=None, callback=None):
"""The dummy arguments are to test that this fit function can
accept non-array arguments through cross-validation, such as:
- int
- str (this is actually array-like)
- object
- function
"""
self.dummy_int = dummy_int
self.dummy_str = dummy_str
self.dummy_obj = dummy_obj
if callback is not None:
callback(self)
if self.allow_nd:
X = X.reshape(len(X), -1)
if X.ndim >= 3 and not self.allow_nd:
raise ValueError('X cannot be d')
if sample_weight is not None:
assert_true(sample_weight.shape[0] == X.shape[0],
'MockClassifier extra fit_param sample_weight.shape[0]'
' is {0}, should be {1}'.format(sample_weight.shape[0],
X.shape[0]))
if class_prior is not None:
assert_true(class_prior.shape[0] == len(np.unique(y)),
'MockClassifier extra fit_param class_prior.shape[0]'
' is {0}, should be {1}'.format(class_prior.shape[0],
len(np.unique(y))))
if sparse_sample_weight is not None:
fmt = ('MockClassifier extra fit_param sparse_sample_weight'
'.shape[0] is {0}, should be {1}')
assert_true(sparse_sample_weight.shape[0] == X.shape[0],
fmt.format(sparse_sample_weight.shape[0], X.shape[0]))
if sparse_param is not None:
fmt = ('MockClassifier extra fit_param sparse_param.shape '
'is ({0}, {1}), should be ({2}, {3})')
assert_true(sparse_param.shape == P_sparse.shape,
fmt.format(sparse_param.shape[0],
sparse_param.shape[1],
P_sparse.shape[0], P_sparse.shape[1]))
return self
def predict(self, T):
if self.allow_nd:
T = T.reshape(len(T), -1)
return T[:, 0]
def score(self, X=None, Y=None):
return 1. / (1 + np.abs(self.a))
def get_params(self, deep=False):
return {'a': self.a, 'allow_nd': self.allow_nd}
X = np.ones((10, 2))
X_sparse = coo_matrix(X)
W_sparse = coo_matrix((np.array([1]), (np.array([1]), np.array([0]))),
shape=(10, 1))
P_sparse = coo_matrix(np.eye(5))
y = np.arange(10) // 2
##############################################################################
# Tests
def check_valid_split(train, test, n_samples=None):
# Use python sets to get more informative assertion failure messages
train, test = set(train), set(test)
# Train and test split should not overlap
assert_equal(train.intersection(test), set())
if n_samples is not None:
# Check that the union of train an test split cover all the indices
assert_equal(train.union(test), set(range(n_samples)))
def check_cv_coverage(cv, expected_n_iter=None, n_samples=None):
# Check that a all the samples appear at least once in a test fold
if expected_n_iter is not None:
assert_equal(len(cv), expected_n_iter)
else:
expected_n_iter = len(cv)
collected_test_samples = set()
iterations = 0
for train, test in cv:
check_valid_split(train, test, n_samples=n_samples)
iterations += 1
collected_test_samples.update(test)
# Check that the accumulated test samples cover the whole dataset
assert_equal(iterations, expected_n_iter)
if n_samples is not None:
assert_equal(collected_test_samples, set(range(n_samples)))
def test_kfold_valueerrors():
# Check that errors are raised if there is not enough samples
assert_raises(ValueError, cval.KFold, 3, 4)
# Check that a warning is raised if the least populated class has too few
# members.
y = [3, 3, -1, -1, 2]
cv = assert_warns_message(Warning, "The least populated class",
cval.StratifiedKFold, y, 3)
# Check that despite the warning the folds are still computed even
# though all the classes are not necessarily represented at on each
# side of the split at each split
check_cv_coverage(cv, expected_n_iter=3, n_samples=len(y))
# Error when number of folds is <= 1
assert_raises(ValueError, cval.KFold, 2, 0)
assert_raises(ValueError, cval.KFold, 2, 1)
assert_raises(ValueError, cval.StratifiedKFold, y, 0)
assert_raises(ValueError, cval.StratifiedKFold, y, 1)
# When n is not integer:
assert_raises(ValueError, cval.KFold, 2.5, 2)
# When n_folds is not integer:
assert_raises(ValueError, cval.KFold, 5, 1.5)
assert_raises(ValueError, cval.StratifiedKFold, y, 1.5)
def test_kfold_indices():
# Check all indices are returned in the test folds
kf = cval.KFold(300, 3)
check_cv_coverage(kf, expected_n_iter=3, n_samples=300)
# Check all indices are returned in the test folds even when equal-sized
# folds are not possible
kf = cval.KFold(17, 3)
check_cv_coverage(kf, expected_n_iter=3, n_samples=17)
def test_kfold_no_shuffle():
# Manually check that KFold preserves the data ordering on toy datasets
splits = iter(cval.KFold(4, 2))
train, test = next(splits)
assert_array_equal(test, [0, 1])
assert_array_equal(train, [2, 3])
train, test = next(splits)
assert_array_equal(test, [2, 3])
assert_array_equal(train, [0, 1])
splits = iter(cval.KFold(5, 2))
train, test = next(splits)
assert_array_equal(test, [0, 1, 2])
assert_array_equal(train, [3, 4])
train, test = next(splits)
assert_array_equal(test, [3, 4])
assert_array_equal(train, [0, 1, 2])
def test_stratified_kfold_no_shuffle():
# Manually check that StratifiedKFold preserves the data ordering as much
# as possible on toy datasets in order to avoid hiding sample dependencies
# when possible
splits = iter(cval.StratifiedKFold([1, 1, 0, 0], 2))
train, test = next(splits)
assert_array_equal(test, [0, 2])
assert_array_equal(train, [1, 3])
train, test = next(splits)
assert_array_equal(test, [1, 3])
assert_array_equal(train, [0, 2])
splits = iter(cval.StratifiedKFold([1, 1, 1, 0, 0, 0, 0], 2))
train, test = next(splits)
assert_array_equal(test, [0, 1, 3, 4])
assert_array_equal(train, [2, 5, 6])
train, test = next(splits)
assert_array_equal(test, [2, 5, 6])
assert_array_equal(train, [0, 1, 3, 4])
def test_stratified_kfold_ratios():
# Check that stratified kfold preserves label ratios in individual splits
# Repeat with shuffling turned off and on
n_samples = 1000
labels = np.array([4] * int(0.10 * n_samples) +
[0] * int(0.89 * n_samples) +
[1] * int(0.01 * n_samples))
for shuffle in [False, True]:
for train, test in cval.StratifiedKFold(labels, 5, shuffle=shuffle):
assert_almost_equal(np.sum(labels[train] == 4) / len(train), 0.10,
2)
assert_almost_equal(np.sum(labels[train] == 0) / len(train), 0.89,
2)
assert_almost_equal(np.sum(labels[train] == 1) / len(train), 0.01,
2)
assert_almost_equal(np.sum(labels[test] == 4) / len(test), 0.10, 2)
assert_almost_equal(np.sum(labels[test] == 0) / len(test), 0.89, 2)
assert_almost_equal(np.sum(labels[test] == 1) / len(test), 0.01, 2)
def test_kfold_balance():
# Check that KFold returns folds with balanced sizes
for kf in [cval.KFold(i, 5) for i in range(11, 17)]:
sizes = []
for _, test in kf:
sizes.append(len(test))
assert_true((np.max(sizes) - np.min(sizes)) <= 1)
assert_equal(np.sum(sizes), kf.n)
def test_stratifiedkfold_balance():
# Check that KFold returns folds with balanced sizes (only when
# stratification is possible)
# Repeat with shuffling turned off and on
labels = [0] * 3 + [1] * 14
for shuffle in [False, True]:
for skf in [cval.StratifiedKFold(labels[:i], 3, shuffle=shuffle)
for i in range(11, 17)]:
sizes = []
for _, test in skf:
sizes.append(len(test))
assert_true((np.max(sizes) - np.min(sizes)) <= 1)
assert_equal(np.sum(sizes), skf.n)
def test_shuffle_kfold():
# Check the indices are shuffled properly, and that all indices are
# returned in the different test folds
kf = cval.KFold(300, 3, shuffle=True, random_state=0)
ind = np.arange(300)
all_folds = None
for train, test in kf:
sorted_array = np.arange(100)
assert_true(np.any(sorted_array != ind[train]))
sorted_array = np.arange(101, 200)
assert_true(np.any(sorted_array != ind[train]))
sorted_array = np.arange(201, 300)
assert_true(np.any(sorted_array != ind[train]))
if all_folds is None:
all_folds = ind[test].copy()
else:
all_folds = np.concatenate((all_folds, ind[test]))
all_folds.sort()
assert_array_equal(all_folds, ind)
def test_shuffle_stratifiedkfold():
# Check that shuffling is happening when requested, and for proper
# sample coverage
labels = [0] * 20 + [1] * 20
kf0 = list(cval.StratifiedKFold(labels, 5, shuffle=True, random_state=0))
kf1 = list(cval.StratifiedKFold(labels, 5, shuffle=True, random_state=1))
for (_, test0), (_, test1) in zip(kf0, kf1):
assert_true(set(test0) != set(test1))
check_cv_coverage(kf0, expected_n_iter=5, n_samples=40)
def test_kfold_can_detect_dependent_samples_on_digits(): # see #2372
# The digits samples are dependent: they are apparently grouped by authors
# although we don't have any information on the groups segment locations
# for this data. We can highlight this fact be computing k-fold cross-
# validation with and without shuffling: we observe that the shuffling case
# wrongly makes the IID assumption and is therefore too optimistic: it
# estimates a much higher accuracy (around 0.96) than than the non
# shuffling variant (around 0.86).
digits = load_digits()
X, y = digits.data[:800], digits.target[:800]
model = SVC(C=10, gamma=0.005)
n = len(y)
cv = cval.KFold(n, 5, shuffle=False)
mean_score = cval.cross_val_score(model, X, y, cv=cv).mean()
assert_greater(0.88, mean_score)
assert_greater(mean_score, 0.85)
# Shuffling the data artificially breaks the dependency and hides the
# overfitting of the model with regards to the writing style of the authors
# by yielding a seriously overestimated score:
cv = cval.KFold(n, 5, shuffle=True, random_state=0)
mean_score = cval.cross_val_score(model, X, y, cv=cv).mean()
assert_greater(mean_score, 0.95)
cv = cval.KFold(n, 5, shuffle=True, random_state=1)
mean_score = cval.cross_val_score(model, X, y, cv=cv).mean()
assert_greater(mean_score, 0.95)
# Similarly, StratifiedKFold should try to shuffle the data as little
# as possible (while respecting the balanced class constraints)
# and thus be able to detect the dependency by not overestimating
# the CV score either. As the digits dataset is approximately balanced
# the estimated mean score is close to the score measured with
# non-shuffled KFold
cv = cval.StratifiedKFold(y, 5)
mean_score = cval.cross_val_score(model, X, y, cv=cv).mean()
assert_greater(0.88, mean_score)
assert_greater(mean_score, 0.85)
def test_shuffle_split():
ss1 = cval.ShuffleSplit(10, test_size=0.2, random_state=0)
ss2 = cval.ShuffleSplit(10, test_size=2, random_state=0)
ss3 = cval.ShuffleSplit(10, test_size=np.int32(2), random_state=0)
for typ in six.integer_types:
ss4 = cval.ShuffleSplit(10, test_size=typ(2), random_state=0)
for t1, t2, t3, t4 in zip(ss1, ss2, ss3, ss4):
assert_array_equal(t1[0], t2[0])
assert_array_equal(t2[0], t3[0])
assert_array_equal(t3[0], t4[0])
assert_array_equal(t1[1], t2[1])
assert_array_equal(t2[1], t3[1])
assert_array_equal(t3[1], t4[1])
def test_stratified_shuffle_split_init():
y = np.asarray([0, 1, 1, 1, 2, 2, 2])
# Check that error is raised if there is a class with only one sample
assert_raises(ValueError, cval.StratifiedShuffleSplit, y, 3, 0.2)
# Check that error is raised if the test set size is smaller than n_classes
assert_raises(ValueError, cval.StratifiedShuffleSplit, y, 3, 2)
# Check that error is raised if the train set size is smaller than
# n_classes
assert_raises(ValueError, cval.StratifiedShuffleSplit, y, 3, 3, 2)
y = np.asarray([0, 0, 0, 1, 1, 1, 2, 2, 2])
# Check that errors are raised if there is not enough samples
assert_raises(ValueError, cval.StratifiedShuffleSplit, y, 3, 0.5, 0.6)
assert_raises(ValueError, cval.StratifiedShuffleSplit, y, 3, 8, 0.6)
assert_raises(ValueError, cval.StratifiedShuffleSplit, y, 3, 0.6, 8)
# Train size or test size too small
assert_raises(ValueError, cval.StratifiedShuffleSplit, y, train_size=2)
assert_raises(ValueError, cval.StratifiedShuffleSplit, y, test_size=2)
def test_stratified_shuffle_split_iter():
ys = [np.array([1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3]),
np.array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3]),
np.array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2]),
np.array([1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4]),
np.array([-1] * 800 + [1] * 50)
]
for y in ys:
sss = cval.StratifiedShuffleSplit(y, 6, test_size=0.33,
random_state=0)
for train, test in sss:
assert_array_equal(np.unique(y[train]), np.unique(y[test]))
# Checks if folds keep classes proportions
p_train = (np.bincount(np.unique(y[train], return_inverse=True)[1])
/ float(len(y[train])))
p_test = (np.bincount(np.unique(y[test], return_inverse=True)[1])
/ float(len(y[test])))
assert_array_almost_equal(p_train, p_test, 1)
assert_equal(y[train].size + y[test].size, y.size)
assert_array_equal(np.lib.arraysetops.intersect1d(train, test), [])
def test_stratified_shuffle_split_even():
# Test the StratifiedShuffleSplit, indices are drawn with a
# equal chance
n_folds = 5
n_iter = 1000
def assert_counts_are_ok(idx_counts, p):
# Here we test that the distribution of the counts
# per index is close enough to a binomial
threshold = 0.05 / n_splits
bf = stats.binom(n_splits, p)
for count in idx_counts:
p = bf.pmf(count)
assert_true(p > threshold,
"An index is not drawn with chance corresponding "
"to even draws")
for n_samples in (6, 22):
labels = np.array((n_samples // 2) * [0, 1])
splits = cval.StratifiedShuffleSplit(labels, n_iter=n_iter,
test_size=1. / n_folds,
random_state=0)
train_counts = [0] * n_samples
test_counts = [0] * n_samples
n_splits = 0
for train, test in splits:
n_splits += 1
for counter, ids in [(train_counts, train), (test_counts, test)]:
for id in ids:
counter[id] += 1
assert_equal(n_splits, n_iter)
assert_equal(len(train), splits.n_train)
assert_equal(len(test), splits.n_test)
assert_equal(len(set(train).intersection(test)), 0)
label_counts = np.unique(labels)
assert_equal(splits.test_size, 1.0 / n_folds)
assert_equal(splits.n_train + splits.n_test, len(labels))
assert_equal(len(label_counts), 2)
ex_test_p = float(splits.n_test) / n_samples
ex_train_p = float(splits.n_train) / n_samples
assert_counts_are_ok(train_counts, ex_train_p)
assert_counts_are_ok(test_counts, ex_test_p)
def test_predefinedsplit_with_kfold_split():
# Check that PredefinedSplit can reproduce a split generated by Kfold.
folds = -1 * np.ones(10)
kf_train = []
kf_test = []
for i, (train_ind, test_ind) in enumerate(cval.KFold(10, 5, shuffle=True)):
kf_train.append(train_ind)
kf_test.append(test_ind)
folds[test_ind] = i
ps_train = []
ps_test = []
ps = cval.PredefinedSplit(folds)
for train_ind, test_ind in ps:
ps_train.append(train_ind)
ps_test.append(test_ind)
assert_array_equal(ps_train, kf_train)
assert_array_equal(ps_test, kf_test)
def test_leave_label_out_changing_labels():
# Check that LeaveOneLabelOut and LeavePLabelOut work normally if
# the labels variable is changed before calling __iter__
labels = np.array([0, 1, 2, 1, 1, 2, 0, 0])
labels_changing = np.array(labels, copy=True)
lolo = cval.LeaveOneLabelOut(labels)
lolo_changing = cval.LeaveOneLabelOut(labels_changing)
lplo = cval.LeavePLabelOut(labels, p=2)
lplo_changing = cval.LeavePLabelOut(labels_changing, p=2)
labels_changing[:] = 0
for llo, llo_changing in [(lolo, lolo_changing), (lplo, lplo_changing)]:
for (train, test), (train_chan, test_chan) in zip(llo, llo_changing):
assert_array_equal(train, train_chan)
assert_array_equal(test, test_chan)
def test_cross_val_score():
clf = MockClassifier()
for a in range(-10, 10):
clf.a = a
# Smoke test
scores = cval.cross_val_score(clf, X, y)
assert_array_equal(scores, clf.score(X, y))
# test with multioutput y
scores = cval.cross_val_score(clf, X_sparse, X)
assert_array_equal(scores, clf.score(X_sparse, X))
scores = cval.cross_val_score(clf, X_sparse, y)
assert_array_equal(scores, clf.score(X_sparse, y))
# test with multioutput y
scores = cval.cross_val_score(clf, X_sparse, X)
assert_array_equal(scores, clf.score(X_sparse, X))
# test with X and y as list
list_check = lambda x: isinstance(x, list)
clf = CheckingClassifier(check_X=list_check)
scores = cval.cross_val_score(clf, X.tolist(), y.tolist())
clf = CheckingClassifier(check_y=list_check)
scores = cval.cross_val_score(clf, X, y.tolist())
assert_raises(ValueError, cval.cross_val_score, clf, X, y,
scoring="sklearn")
# test with 3d X and
X_3d = X[:, :, np.newaxis]
clf = MockClassifier(allow_nd=True)
scores = cval.cross_val_score(clf, X_3d, y)
clf = MockClassifier(allow_nd=False)
assert_raises(ValueError, cval.cross_val_score, clf, X_3d, y)
def test_cross_val_score_pandas():
# check cross_val_score doesn't destroy pandas dataframe
types = [(MockDataFrame, MockDataFrame)]
try:
from pandas import Series, DataFrame
types.append((Series, DataFrame))
except ImportError:
pass
for TargetType, InputFeatureType in types:
# X dataframe, y series
X_df, y_ser = InputFeatureType(X), TargetType(y)
check_df = lambda x: isinstance(x, InputFeatureType)
check_series = lambda x: isinstance(x, TargetType)
clf = CheckingClassifier(check_X=check_df, check_y=check_series)
cval.cross_val_score(clf, X_df, y_ser)
def test_cross_val_score_mask():
# test that cross_val_score works with boolean masks
svm = SVC(kernel="linear")
iris = load_iris()
X, y = iris.data, iris.target
cv_indices = cval.KFold(len(y), 5)
scores_indices = cval.cross_val_score(svm, X, y, cv=cv_indices)
cv_indices = cval.KFold(len(y), 5)
cv_masks = []
for train, test in cv_indices:
mask_train = np.zeros(len(y), dtype=np.bool)
mask_test = np.zeros(len(y), dtype=np.bool)
mask_train[train] = 1
mask_test[test] = 1
cv_masks.append((train, test))
scores_masks = cval.cross_val_score(svm, X, y, cv=cv_masks)
assert_array_equal(scores_indices, scores_masks)
def test_cross_val_score_precomputed():
# test for svm with precomputed kernel
svm = SVC(kernel="precomputed")
iris = load_iris()
X, y = iris.data, iris.target
linear_kernel = np.dot(X, X.T)
score_precomputed = cval.cross_val_score(svm, linear_kernel, y)
svm = SVC(kernel="linear")
score_linear = cval.cross_val_score(svm, X, y)
assert_array_equal(score_precomputed, score_linear)
# Error raised for non-square X
svm = SVC(kernel="precomputed")
assert_raises(ValueError, cval.cross_val_score, svm, X, y)
# test error is raised when the precomputed kernel is not array-like
# or sparse
assert_raises(ValueError, cval.cross_val_score, svm,
linear_kernel.tolist(), y)
def test_cross_val_score_fit_params():
clf = MockClassifier()
n_samples = X.shape[0]
n_classes = len(np.unique(y))
DUMMY_INT = 42
DUMMY_STR = '42'
DUMMY_OBJ = object()
def assert_fit_params(clf):
# Function to test that the values are passed correctly to the
# classifier arguments for non-array type
assert_equal(clf.dummy_int, DUMMY_INT)
assert_equal(clf.dummy_str, DUMMY_STR)
assert_equal(clf.dummy_obj, DUMMY_OBJ)
fit_params = {'sample_weight': np.ones(n_samples),
'class_prior': np.ones(n_classes) / n_classes,
'sparse_sample_weight': W_sparse,
'sparse_param': P_sparse,
'dummy_int': DUMMY_INT,
'dummy_str': DUMMY_STR,
'dummy_obj': DUMMY_OBJ,
'callback': assert_fit_params}
cval.cross_val_score(clf, X, y, fit_params=fit_params)
def test_cross_val_score_score_func():
clf = MockClassifier()
_score_func_args = []
def score_func(y_test, y_predict):
_score_func_args.append((y_test, y_predict))
return 1.0
with warnings.catch_warnings(record=True):
scoring = make_scorer(score_func)
score = cval.cross_val_score(clf, X, y, scoring=scoring)
assert_array_equal(score, [1.0, 1.0, 1.0])
assert len(_score_func_args) == 3
def test_cross_val_score_errors():
class BrokenEstimator:
pass
assert_raises(TypeError, cval.cross_val_score, BrokenEstimator(), X)
def test_train_test_split_errors():
assert_raises(ValueError, cval.train_test_split)
assert_raises(ValueError, cval.train_test_split, range(3), train_size=1.1)
assert_raises(ValueError, cval.train_test_split, range(3), test_size=0.6,
train_size=0.6)
assert_raises(ValueError, cval.train_test_split, range(3),
test_size=np.float32(0.6), train_size=np.float32(0.6))
assert_raises(ValueError, cval.train_test_split, range(3),
test_size="wrong_type")
assert_raises(ValueError, cval.train_test_split, range(3), test_size=2,
train_size=4)
assert_raises(TypeError, cval.train_test_split, range(3),
some_argument=1.1)
assert_raises(ValueError, cval.train_test_split, range(3), range(42))
def test_train_test_split():
X = np.arange(100).reshape((10, 10))
X_s = coo_matrix(X)
y = np.arange(10)
# simple test
split = cval.train_test_split(X, y, test_size=None, train_size=.5)
X_train, X_test, y_train, y_test = split
assert_equal(len(y_test), len(y_train))
# test correspondence of X and y
assert_array_equal(X_train[:, 0], y_train * 10)
assert_array_equal(X_test[:, 0], y_test * 10)
# conversion of lists to arrays (deprecated?)
with warnings.catch_warnings(record=True):
split = cval.train_test_split(X, X_s, y.tolist(), allow_lists=False)
X_train, X_test, X_s_train, X_s_test, y_train, y_test = split
assert_array_equal(X_train, X_s_train.toarray())
assert_array_equal(X_test, X_s_test.toarray())
# don't convert lists to anything else by default
split = cval.train_test_split(X, X_s, y.tolist())
X_train, X_test, X_s_train, X_s_test, y_train, y_test = split
assert_true(isinstance(y_train, list))
assert_true(isinstance(y_test, list))
# allow nd-arrays
X_4d = np.arange(10 * 5 * 3 * 2).reshape(10, 5, 3, 2)
y_3d = np.arange(10 * 7 * 11).reshape(10, 7, 11)
split = cval.train_test_split(X_4d, y_3d)
assert_equal(split[0].shape, (7, 5, 3, 2))
assert_equal(split[1].shape, (3, 5, 3, 2))
assert_equal(split[2].shape, (7, 7, 11))
assert_equal(split[3].shape, (3, 7, 11))
# test stratification option
y = np.array([1, 1, 1, 1, 2, 2, 2, 2])
for test_size, exp_test_size in zip([2, 4, 0.25, 0.5, 0.75],
[2, 4, 2, 4, 6]):
train, test = cval.train_test_split(y,
test_size=test_size,
stratify=y,
random_state=0)
assert_equal(len(test), exp_test_size)
assert_equal(len(test) + len(train), len(y))
# check the 1:1 ratio of ones and twos in the data is preserved
assert_equal(np.sum(train == 1), np.sum(train == 2))
def train_test_split_pandas():
# check cross_val_score doesn't destroy pandas dataframe
types = [MockDataFrame]
try:
from pandas import DataFrame
types.append(DataFrame)
except ImportError:
pass
for InputFeatureType in types:
# X dataframe
X_df = InputFeatureType(X)
X_train, X_test = cval.train_test_split(X_df)
assert_true(isinstance(X_train, InputFeatureType))
assert_true(isinstance(X_test, InputFeatureType))
def train_test_split_mock_pandas():
# X mock dataframe
X_df = MockDataFrame(X)
X_train, X_test = cval.train_test_split(X_df)
assert_true(isinstance(X_train, MockDataFrame))
assert_true(isinstance(X_test, MockDataFrame))
X_train_arr, X_test_arr = cval.train_test_split(X_df, allow_lists=False)
assert_true(isinstance(X_train_arr, np.ndarray))
assert_true(isinstance(X_test_arr, np.ndarray))
def test_cross_val_score_with_score_func_classification():
iris = load_iris()
clf = SVC(kernel='linear')
# Default score (should be the accuracy score)
scores = cval.cross_val_score(clf, iris.data, iris.target, cv=5)
assert_array_almost_equal(scores, [0.97, 1., 0.97, 0.97, 1.], 2)
# Correct classification score (aka. zero / one score) - should be the
# same as the default estimator score
zo_scores = cval.cross_val_score(clf, iris.data, iris.target,
scoring="accuracy", cv=5)
assert_array_almost_equal(zo_scores, [0.97, 1., 0.97, 0.97, 1.], 2)
# F1 score (class are balanced so f1_score should be equal to zero/one
# score
f1_scores = cval.cross_val_score(clf, iris.data, iris.target,
scoring="f1_weighted", cv=5)
assert_array_almost_equal(f1_scores, [0.97, 1., 0.97, 0.97, 1.], 2)
def test_cross_val_score_with_score_func_regression():
X, y = make_regression(n_samples=30, n_features=20, n_informative=5,
random_state=0)
reg = Ridge()
# Default score of the Ridge regression estimator
scores = cval.cross_val_score(reg, X, y, cv=5)
assert_array_almost_equal(scores, [0.94, 0.97, 0.97, 0.99, 0.92], 2)
# R2 score (aka. determination coefficient) - should be the
# same as the default estimator score
r2_scores = cval.cross_val_score(reg, X, y, scoring="r2", cv=5)
assert_array_almost_equal(r2_scores, [0.94, 0.97, 0.97, 0.99, 0.92], 2)
# Mean squared error; this is a loss function, so "scores" are negative
mse_scores = cval.cross_val_score(reg, X, y, cv=5,
scoring="mean_squared_error")
expected_mse = np.array([-763.07, -553.16, -274.38, -273.26, -1681.99])
assert_array_almost_equal(mse_scores, expected_mse, 2)
# Explained variance
scoring = make_scorer(explained_variance_score)
ev_scores = cval.cross_val_score(reg, X, y, cv=5, scoring=scoring)
assert_array_almost_equal(ev_scores, [0.94, 0.97, 0.97, 0.99, 0.92], 2)
def test_permutation_score():
iris = load_iris()
X = iris.data
X_sparse = coo_matrix(X)
y = iris.target
svm = SVC(kernel='linear')
cv = cval.StratifiedKFold(y, 2)
score, scores, pvalue = cval.permutation_test_score(
svm, X, y, n_permutations=30, cv=cv, scoring="accuracy")
assert_greater(score, 0.9)
assert_almost_equal(pvalue, 0.0, 1)
score_label, _, pvalue_label = cval.permutation_test_score(
svm, X, y, n_permutations=30, cv=cv, scoring="accuracy",
labels=np.ones(y.size), random_state=0)
assert_true(score_label == score)
assert_true(pvalue_label == pvalue)
# check that we obtain the same results with a sparse representation
svm_sparse = SVC(kernel='linear')
cv_sparse = cval.StratifiedKFold(y, 2)
score_label, _, pvalue_label = cval.permutation_test_score(
svm_sparse, X_sparse, y, n_permutations=30, cv=cv_sparse,
scoring="accuracy", labels=np.ones(y.size), random_state=0)
assert_true(score_label == score)
assert_true(pvalue_label == pvalue)
# test with custom scoring object
def custom_score(y_true, y_pred):
return (((y_true == y_pred).sum() - (y_true != y_pred).sum())
/ y_true.shape[0])
scorer = make_scorer(custom_score)
score, _, pvalue = cval.permutation_test_score(
svm, X, y, n_permutations=100, scoring=scorer, cv=cv, random_state=0)
assert_almost_equal(score, .93, 2)
assert_almost_equal(pvalue, 0.01, 3)
# set random y
y = np.mod(np.arange(len(y)), 3)
score, scores, pvalue = cval.permutation_test_score(
svm, X, y, n_permutations=30, cv=cv, scoring="accuracy")
assert_less(score, 0.5)
assert_greater(pvalue, 0.2)
def test_cross_val_generator_with_indices():
X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
y = np.array([1, 1, 2, 2])
labels = np.array([1, 2, 3, 4])
# explicitly passing indices value is deprecated
loo = cval.LeaveOneOut(4)
lpo = cval.LeavePOut(4, 2)
kf = cval.KFold(4, 2)
skf = cval.StratifiedKFold(y, 2)
lolo = cval.LeaveOneLabelOut(labels)
lopo = cval.LeavePLabelOut(labels, 2)
ps = cval.PredefinedSplit([1, 1, 2, 2])
ss = cval.ShuffleSplit(2)
for cv in [loo, lpo, kf, skf, lolo, lopo, ss, ps]:
for train, test in cv:
assert_not_equal(np.asarray(train).dtype.kind, 'b')
assert_not_equal(np.asarray(train).dtype.kind, 'b')
X[train], X[test]
y[train], y[test]
@ignore_warnings
def test_cross_val_generator_with_default_indices():
X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
y = np.array([1, 1, 2, 2])
labels = np.array([1, 2, 3, 4])
loo = cval.LeaveOneOut(4)
lpo = cval.LeavePOut(4, 2)
kf = cval.KFold(4, 2)
skf = cval.StratifiedKFold(y, 2)
lolo = cval.LeaveOneLabelOut(labels)
lopo = cval.LeavePLabelOut(labels, 2)
ss = cval.ShuffleSplit(2)
ps = cval.PredefinedSplit([1, 1, 2, 2])
for cv in [loo, lpo, kf, skf, lolo, lopo, ss, ps]:
for train, test in cv:
assert_not_equal(np.asarray(train).dtype.kind, 'b')
assert_not_equal(np.asarray(train).dtype.kind, 'b')
X[train], X[test]
y[train], y[test]
def test_shufflesplit_errors():
assert_raises(ValueError, cval.ShuffleSplit, 10, test_size=2.0)
assert_raises(ValueError, cval.ShuffleSplit, 10, test_size=1.0)
assert_raises(ValueError, cval.ShuffleSplit, 10, test_size=0.1,
train_size=0.95)
assert_raises(ValueError, cval.ShuffleSplit, 10, test_size=11)
assert_raises(ValueError, cval.ShuffleSplit, 10, test_size=10)
assert_raises(ValueError, cval.ShuffleSplit, 10, test_size=8, train_size=3)
assert_raises(ValueError, cval.ShuffleSplit, 10, train_size=1j)
assert_raises(ValueError, cval.ShuffleSplit, 10, test_size=None,
train_size=None)
def test_shufflesplit_reproducible():
# Check that iterating twice on the ShuffleSplit gives the same
# sequence of train-test when the random_state is given
ss = cval.ShuffleSplit(10, random_state=21)
assert_array_equal(list(a for a, b in ss), list(a for a, b in ss))
def test_safe_split_with_precomputed_kernel():
clf = SVC()
clfp = SVC(kernel="precomputed")
iris = load_iris()
X, y = iris.data, iris.target
K = np.dot(X, X.T)
cv = cval.ShuffleSplit(X.shape[0], test_size=0.25, random_state=0)
tr, te = list(cv)[0]
X_tr, y_tr = cval._safe_split(clf, X, y, tr)
K_tr, y_tr2 = cval._safe_split(clfp, K, y, tr)
assert_array_almost_equal(K_tr, np.dot(X_tr, X_tr.T))
X_te, y_te = cval._safe_split(clf, X, y, te, tr)
K_te, y_te2 = cval._safe_split(clfp, K, y, te, tr)
assert_array_almost_equal(K_te, np.dot(X_te, X_tr.T))
def test_cross_val_score_allow_nans():
# Check that cross_val_score allows input data with NaNs
X = np.arange(200, dtype=np.float64).reshape(10, -1)
X[2, :] = np.nan
y = np.repeat([0, 1], X.shape[0] / 2)
p = Pipeline([
('imputer', Imputer(strategy='mean', missing_values='NaN')),
('classifier', MockClassifier()),
])
cval.cross_val_score(p, X, y, cv=5)
def test_train_test_split_allow_nans():
# Check that train_test_split allows input data with NaNs
X = np.arange(200, dtype=np.float64).reshape(10, -1)
X[2, :] = np.nan
y = np.repeat([0, 1], X.shape[0] / 2)
cval.train_test_split(X, y, test_size=0.2, random_state=42)
def test_permutation_test_score_allow_nans():
# Check that permutation_test_score allows input data with NaNs
X = np.arange(200, dtype=np.float64).reshape(10, -1)
X[2, :] = np.nan
y = np.repeat([0, 1], X.shape[0] / 2)
p = Pipeline([
('imputer', Imputer(strategy='mean', missing_values='NaN')),
('classifier', MockClassifier()),
])
cval.permutation_test_score(p, X, y, cv=5)
def test_check_cv_return_types():
X = np.ones((9, 2))
cv = cval.check_cv(3, X, classifier=False)
assert_true(isinstance(cv, cval.KFold))
y_binary = np.array([0, 1, 0, 1, 0, 0, 1, 1, 1])
cv = cval.check_cv(3, X, y_binary, classifier=True)
assert_true(isinstance(cv, cval.StratifiedKFold))
y_multiclass = np.array([0, 1, 0, 1, 2, 1, 2, 0, 2])
cv = cval.check_cv(3, X, y_multiclass, classifier=True)
assert_true(isinstance(cv, cval.StratifiedKFold))
X = np.ones((5, 2))
y_multilabel = [[1, 0, 1], [1, 1, 0], [0, 0, 0], [0, 1, 1], [1, 0, 0]]
cv = cval.check_cv(3, X, y_multilabel, classifier=True)
assert_true(isinstance(cv, cval.KFold))
y_multioutput = np.array([[1, 2], [0, 3], [0, 0], [3, 1], [2, 0]])
cv = cval.check_cv(3, X, y_multioutput, classifier=True)
assert_true(isinstance(cv, cval.KFold))
def test_cross_val_score_multilabel():
X = np.array([[-3, 4], [2, 4], [3, 3], [0, 2], [-3, 1],
[-2, 1], [0, 0], [-2, -1], [-1, -2], [1, -2]])
y = np.array([[1, 1], [0, 1], [0, 1], [0, 1], [1, 1],
[0, 1], [1, 0], [1, 1], [1, 0], [0, 0]])
clf = KNeighborsClassifier(n_neighbors=1)
scoring_micro = make_scorer(precision_score, average='micro')
scoring_macro = make_scorer(precision_score, average='macro')
scoring_samples = make_scorer(precision_score, average='samples')
score_micro = cval.cross_val_score(clf, X, y, scoring=scoring_micro, cv=5)
score_macro = cval.cross_val_score(clf, X, y, scoring=scoring_macro, cv=5)
score_samples = cval.cross_val_score(clf, X, y,
scoring=scoring_samples, cv=5)
assert_almost_equal(score_micro, [1, 1 / 2, 3 / 4, 1 / 2, 1 / 3])
assert_almost_equal(score_macro, [1, 1 / 2, 3 / 4, 1 / 2, 1 / 4])
assert_almost_equal(score_samples, [1, 1 / 2, 3 / 4, 1 / 2, 1 / 4])
def test_cross_val_predict():
boston = load_boston()
X, y = boston.data, boston.target
cv = cval.KFold(len(boston.target))
est = Ridge()
# Naive loop (should be same as cross_val_predict):
preds2 = np.zeros_like(y)
for train, test in cv:
est.fit(X[train], y[train])
preds2[test] = est.predict(X[test])
preds = cval.cross_val_predict(est, X, y, cv=cv)
assert_array_almost_equal(preds, preds2)
preds = cval.cross_val_predict(est, X, y)
assert_equal(len(preds), len(y))
cv = cval.LeaveOneOut(len(y))
preds = cval.cross_val_predict(est, X, y, cv=cv)
assert_equal(len(preds), len(y))
Xsp = X.copy()
Xsp *= (Xsp > np.median(Xsp))
Xsp = coo_matrix(Xsp)
preds = cval.cross_val_predict(est, Xsp, y)
assert_array_almost_equal(len(preds), len(y))
preds = cval.cross_val_predict(KMeans(), X)
assert_equal(len(preds), len(y))
def bad_cv():
for i in range(4):
yield np.array([0, 1, 2, 3]), np.array([4, 5, 6, 7, 8])
assert_raises(ValueError, cval.cross_val_predict, est, X, y, cv=bad_cv())
def test_cross_val_predict_input_types():
clf = Ridge()
# Smoke test
predictions = cval.cross_val_predict(clf, X, y)
assert_equal(predictions.shape, (10,))
# test with multioutput y
predictions = cval.cross_val_predict(clf, X_sparse, X)
assert_equal(predictions.shape, (10, 2))
predictions = cval.cross_val_predict(clf, X_sparse, y)
assert_array_equal(predictions.shape, (10,))
# test with multioutput y
predictions = cval.cross_val_predict(clf, X_sparse, X)
assert_array_equal(predictions.shape, (10, 2))
# test with X and y as list
list_check = lambda x: isinstance(x, list)
clf = CheckingClassifier(check_X=list_check)
predictions = cval.cross_val_predict(clf, X.tolist(), y.tolist())
clf = CheckingClassifier(check_y=list_check)
predictions = cval.cross_val_predict(clf, X, y.tolist())
# test with 3d X and
X_3d = X[:, :, np.newaxis]
check_3d = lambda x: x.ndim == 3
clf = CheckingClassifier(check_X=check_3d)
predictions = cval.cross_val_predict(clf, X_3d, y)
assert_array_equal(predictions.shape, (10,))
def test_cross_val_predict_pandas():
# check cross_val_score doesn't destroy pandas dataframe
types = [(MockDataFrame, MockDataFrame)]
try:
from pandas import Series, DataFrame
types.append((Series, DataFrame))
except ImportError:
pass
for TargetType, InputFeatureType in types:
# X dataframe, y series
X_df, y_ser = InputFeatureType(X), TargetType(y)
check_df = lambda x: isinstance(x, InputFeatureType)
check_series = lambda x: isinstance(x, TargetType)
clf = CheckingClassifier(check_X=check_df, check_y=check_series)
cval.cross_val_predict(clf, X_df, y_ser)
def test_sparse_fit_params():
iris = load_iris()
X, y = iris.data, iris.target
clf = MockClassifier()
fit_params = {'sparse_sample_weight': coo_matrix(np.eye(X.shape[0]))}
a = cval.cross_val_score(clf, X, y, fit_params=fit_params)
assert_array_equal(a, np.ones(3))
def test_check_is_partition():
p = np.arange(100)
assert_true(cval._check_is_partition(p, 100))
assert_false(cval._check_is_partition(np.delete(p, 23), 100))
p[0] = 23
assert_false(cval._check_is_partition(p, 100))
| bsd-3-clause |
bmazin/ARCONS-pipeline | mosaicing/matchFinder.py | 1 | 10154 | import numpy as np
import tables
import sys
import ephem
import PyGuide as pg
import math
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from util.ObsFile import ObsFile
import os
from PyQt4 import QtGui
from PyQt4 import QtCore
from PyQt4.QtGui import *
import hotpix.hotPixels as hp
from tables import *
from util.FileName import FileName
from photometry.PSFphotometry import PSFphotometry
from util import utils
from util.popup import PopUp
import astrometry.CentroidCalc as cc
import util.ObsFileSeq as ofs
import time
#added by Neil vvvvvv 2/3/2015
class MouseMonitor():
def __init__(self):
pass
def on_click(self,event):
if event.inaxes is self.ax1:
self.xyguess1 = [event.xdata,event.ydata]
print 'Clicked: ',self.xyguess1
elif event.inaxes is self.ax2:
self.xyguess2 = [event.xdata,event.ydata]
print 'Clicked: ',self.xyguess2
def on_scroll_cbar(self,event):
if event.inaxes is self.fig1.cbar.ax:
increment=0.05
currentClim = self.fig1.cbar.mappable.get_clim()
currentRange = currentClim[1]-currentClim[0]
if event.button == 'up':
if QtGui.QApplication.keyboardModifiers()==QtCore.Qt.ControlModifier:
newClim = (currentClim[0]+increment*currentRange,currentClim[1])
elif QtGui.QApplication.keyboardModifiers()==QtCore.Qt.NoModifier:
newClim = (currentClim[0],currentClim[1]+increment*currentRange)
if event.button == 'down':
if QtGui.QApplication.keyboardModifiers()==QtCore.Qt.ControlModifier:
newClim = (currentClim[0]-increment*currentRange,currentClim[1])
elif QtGui.QApplication.keyboardModifiers()==QtCore.Qt.NoModifier:
newClim = (currentClim[0],currentClim[1]-increment*currentRange)
self.fig1.cbar.mappable.set_clim(newClim)
self.fig1.canvas.draw()
elif event.inaxes is self.fig2.cbar.ax:
increment=0.05
currentClim = self.fig2.cbar.mappable.get_clim()
currentRange = currentClim[1]-currentClim[0]
if event.button == 'up':
if QtGui.QApplication.keyboardModifiers()==QtCore.Qt.ControlModifier:
newClim = (currentClim[0]+increment*currentRange,currentClim[1])
elif QtGui.QApplication.keyboardModifiers()==QtCore.Qt.NoModifier:
newClim = (currentClim[0],currentClim[1]+increment*currentRange)
if event.button == 'down':
if QtGui.QApplication.keyboardModifiers()==QtCore.Qt.ControlModifier:
newClim = (currentClim[0]-increment*currentRange,currentClim[1])
elif QtGui.QApplication.keyboardModifiers()==QtCore.Qt.NoModifier:
newClim = (currentClim[0],currentClim[1]-increment*currentRange)
self.fig2.cbar.mappable.set_clim(newClim)
self.fig2.canvas.draw()
def connect(self):
self.cid1 = self.fig1.canvas.mpl_connect('button_press_event', self.on_click)
self.fig1.cbar = self.fig1.colorbar(self.handleMatshow1)
cid1 = self.fig1.canvas.mpl_connect('scroll_event', self.on_scroll_cbar)
self.cid2 = self.fig2.canvas.mpl_connect('button_press_event', self.on_click)
self.fig2.cbar = self.fig2.colorbar(self.handleMatshow2)
cid2 = self.fig2.canvas.mpl_connect('scroll_event', self.on_scroll_cbar)
def getUserObjectGuess(images, norm = None):
'''
This is designed to allow the user to look at two frames, determine whether they contain matching stars,
and if so click on their position withing the image.
'''
flagList = np.array([1,1])
xyguess1 = [0,0]
xyguess2 = [0,0]
image1 = images[0]
image2 = images[1]
map = MouseMonitor()
map.fig1 = plt.figure(1)
map.ax1 = map.fig1.add_subplot(111)
map.ax1.set_title('Star Position Guess')
map.handleMatshow1 = map.ax1.matshow(image1,cmap = mpl.cm.gnuplot2, origin = 'lower', norm=norm)
map.fig2 = plt.figure(2)
map.ax2 = map.fig2.add_subplot(111)
map.ax2.set_title('Star Position Guess')
map.handleMatshow2 = map.ax2.matshow(image2,cmap = mpl.cm.gnuplot2, origin = 'lower', norm=norm)
map.connect()
plt.show()
try:
xyguess1 = map.xyguess1
print 'Guess1 = ' + str(xyguess1)
flagList[0]=0
except AttributeError:
pass
try:
xyguess2 = map.xyguess2
print 'Guess2 = ' + str(xyguess2)
flagList[1]=0
except AttributeError:
pass
xyguesses = np.array([xyguess1,xyguess2])
return xyguesses, flagList
def ObjectFinder(frames, data, RA = None, Dec = None, radiusOfSearch=10, usePsfFit=False):
'''
This allows the user to determine the exact positioning of a star withing a given frame, given that
the star exists in two frames. two images pop up, if they contain the same star, click on it in both images,
and the exact pixel positioning will be determine via centroiding. Some parts are fudged for now.
Inputs:
frames - This is an array of images corresponding to the various frames used for the mosaic. note that
the way this is written as of now requires that the first and last frame include the same star.
I think this is typical so it should not be a problem.
data - this is an array of dictionaries corresponding to each frame. This is generated from
getFrameDict() which I have included in the ObsFileSeq class. This is required.
RA/Dec - these are not used as of now.
Outputs:
all the parameters that are needed for setRm()
Ben also suggested that a cross-correlating technique may be useful for matching frames with no star in them.
What do you guys think? I need to look into it more but I believe that this code can be expanded to also do
cross-correlation. - Neil
'''
offsRA = []
offsDec = []
iframe = []
meanTime = []
for i in range(len(data)):
offsRA.append(data[i]["offsRA"])
offsDec.append(data[i]["offsDec"])
iframe.append(data[i]["iframe"])
meanTime.append(data[i]["meanTime"])
offsRA = np.array(offsRA)
offsDec = np.array(offsDec)
iframe = np.array(iframe)
meanTime = np.array(meanTime)
dpp = []
ang = []
for i in range(1, len(frames)):
images = np.array([frames[i-1], frames[i]])
oRA = np.array([offsRA[i-1], offsRA[i]])
oDec = np.array([offsDec[i-1], offsDec[i]])
print 'Looking for matching Stars...'
print 'frame: ', iframe[i-1], 'Offset RA: ', offsRA[i-1], 'Offset Dec: ', offsDec[i-1]
print 'frame: ', iframe[i], 'Offset RA: ', offsRA[i], 'Offset Dec: ', offsDec[i]
xyguesses, flagList = getUserObjectGuess(images)
if flagList[1]==0 and flagList[0]==0:
print 'match found! - determining centroid positions'
#xycenter1, flag1
cenDict1 = cc.centroidImage(images[1], xyguesses[1], radiusOfSearch=radiusOfSearch, doDS9=False, usePsfFit=usePsfFit)
#xycenter0, flag0
cenDict0 = cc.centroidImage(images[0], xyguesses[0], radiusOfSearch=radiusOfSearch, doDS9=False, usePsfFit=usePsfFit)
print 'Success! Matching stars at: ', cenDict0['xycenter'], cenDict1['xycenter']
#rc1 = np.array(xycenter1)
#rc0 = np.array(xycenter0)
rc1 = np.array(cenDict1['xycenter'])
rc0 = np.array(cenDict0['xycenter'])
dCol = rc1[0] - rc0[0]
dRow = rc1[1] - rc0[1]
dPix = math.sqrt(((rc1-rc0)**2).sum())
#center ra,dec of fram calculated from offsets
dRA = oRA[1]-oRA[0] #arcseconds
dDec = oDec[1]-oDec[0]
dDeg = math.sqrt(dRA**2+dDec**2)/3600 #degrees
degPerPix = dDeg/dPix #plate scale
#rotation
thetaPix = math.atan2(dCol,dRow) #angle from verticle
thetaSky = math.atan2(dRA, dDec) #angle from north
theta = thetaPix-thetaSky #degrees
dpp.append(degPerPix)
ang.append(theta)
elif flagList[1]==1 or flagList[0]==1:
print 'no star found'
dpp = np.array(dpp)
#print dpp
degPerPix = np.mean(dpp)
#print degPerPix
ang = np.array(ang)
print ang
theta = np.mean(ang)
print theta
## Pick two frames where the ra,dec offset is zero,
# usually the beginning and ending frames
print 'Matching stars from the first and last frames'
images = [frames[0], frames[-1]]
print 'frame: ', iframe[0], 'Offset RA: ', offsRA[0], 'Offset Dec: ', offsDec[0]
print 'frame: ', iframe[-1], 'Offset RA: ', offsRA[-1], 'Offset Dec: ', offsDec[-1]
xyguesses, flagList = getUserObjectGuess(images)
#xycenter1, flag1
cenDict1 = cc.centroidImage(images[1], xyguesses[1], radiusOfSearch=radiusOfSearch, doDS9=False, usePsfFit=usePsfFit)
#xycenter0, flag0
cenDict0 = cc.centroidImage(images[0], xyguesses[0], radiusOfSearch=radiusOfSearch, doDS9=False, usePsfFit=usePsfFit)
print 'Success! Matching stars at: ', cenDict0['xycenter'], cenDict1['xycenter']
#start here
rcA = np.array(cenDict0['xycenter'])
rcB = np.array(cenDict1['xycenter'])
sct = math.cos(theta)*degPerPix
sst = math.sin(theta)*degPerPix
# This rotation matrix converts from row,col to ra,dec in degrees
rm = np.array([[sct,-sst],[sst,sct]])
rdA = rm.dot(rcA)
rdB = rm.dot(rcB)
deltaRa = rdB[0]-rdA[0]
deltaTime = meanTime[-1] - meanTime[0]
raArcsecPerSec = 3600*deltaRa/deltaTime
return degPerPix, theta, raArcsecPerSec
| gpl-2.0 |
chraibi/ptr5parser | scripts/plot_framewise.py | 1 | 1382 | # plots the trajectories framewise and produce png files
from sys import argv
import os
import glob
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
if len(argv) <= 1:
print("usage: %s <filename>"%argv[0])
exit(">>>>exit<<<<")
filename = argv[1]
print("load file %s..."%filename)
D = np.loadtxt(filename)
frames = np.unique(D[:, 1])
xmin = np.min(D[:, 2])
xmax = np.max(D[:, 2])
ymin = np.min(D[:, 3])
ymax = np.max(D[:, 3])
fig = plt.figure()
z = np.sort(D[:, 4])
_3D = 0
if z[0] != z[-1]:
ax = fig.add_subplot(111, projection='3d')
print("3D")
_3D = 1
for frame in frames:
d = D[D[:, 1] == frame]
x = d[:, 2]
y = d[:, 3]
if _3D:
z = d[:, 4]
plt.plot(x, y, z, "o", color='b', ms=10)
else:
plt.plot(x, y, "o", color='b', ms=10)
plt.xlim([xmin-0.5, xmax+0.5])
plt.ylim([ymin-0.5, ymax+0.5])
plt.savefig("%.5d.png"%frame)
print("%.5d.png"%frame)
plt.clf()
make_movie = r'ffmpeg -y -framerate 16 -pattern_type glob -i "*.png" -r 25 -f mpeg -vcodec mpeg1video -ar 48000 -b:v 5000k -b:a 128k -acodec mp2 -ar 44100 -ac 1 demo.mpg'
try:
err = os.system(make_movie)
except err:
print("command does not exist. err = %d"%err)
png_files = glob.glob("*.png")
if png_files:
print("remove png files")
for f in png_files:
os.remove(f)
| lgpl-3.0 |
henridwyer/scikit-learn | sklearn/preprocessing/tests/test_data.py | 14 | 37957 | import warnings
import numpy as np
import numpy.linalg as la
from scipy import sparse
from distutils.version import LooseVersion
from sklearn.utils.testing import assert_almost_equal, clean_warning_registry
from sklearn.utils.testing import assert_array_almost_equal
from sklearn.utils.testing import assert_array_equal
from sklearn.utils.testing import assert_equal
from sklearn.utils.testing import assert_greater_equal
from sklearn.utils.testing import assert_less_equal
from sklearn.utils.testing import assert_raises
from sklearn.utils.testing import assert_raises_regex
from sklearn.utils.testing import assert_true
from sklearn.utils.testing import assert_false
from sklearn.utils.testing import assert_warns_message
from sklearn.utils.testing import assert_no_warnings
from sklearn.utils.sparsefuncs import mean_variance_axis
from sklearn.preprocessing.data import _transform_selected
from sklearn.preprocessing.data import Binarizer
from sklearn.preprocessing.data import KernelCenterer
from sklearn.preprocessing.data import Normalizer
from sklearn.preprocessing.data import normalize
from sklearn.preprocessing.data import OneHotEncoder
from sklearn.preprocessing.data import StandardScaler
from sklearn.preprocessing.data import scale
from sklearn.preprocessing.data import MinMaxScaler
from sklearn.preprocessing.data import MaxAbsScaler
from sklearn.preprocessing.data import maxabs_scale
from sklearn.preprocessing.data import RobustScaler
from sklearn.preprocessing.data import robust_scale
from sklearn.preprocessing.data import add_dummy_feature
from sklearn.preprocessing.data import PolynomialFeatures
from sklearn.utils.validation import DataConversionWarning
from sklearn import datasets
iris = datasets.load_iris()
def toarray(a):
if hasattr(a, "toarray"):
a = a.toarray()
return a
def test_polynomial_features():
# Test Polynomial Features
X1 = np.arange(6)[:, np.newaxis]
P1 = np.hstack([np.ones_like(X1),
X1, X1 ** 2, X1 ** 3])
deg1 = 3
X2 = np.arange(6).reshape((3, 2))
x1 = X2[:, :1]
x2 = X2[:, 1:]
P2 = np.hstack([x1 ** 0 * x2 ** 0,
x1 ** 1 * x2 ** 0,
x1 ** 0 * x2 ** 1,
x1 ** 2 * x2 ** 0,
x1 ** 1 * x2 ** 1,
x1 ** 0 * x2 ** 2])
deg2 = 2
for (deg, X, P) in [(deg1, X1, P1), (deg2, X2, P2)]:
P_test = PolynomialFeatures(deg, include_bias=True).fit_transform(X)
assert_array_almost_equal(P_test, P)
P_test = PolynomialFeatures(deg, include_bias=False).fit_transform(X)
assert_array_almost_equal(P_test, P[:, 1:])
interact = PolynomialFeatures(2, interaction_only=True, include_bias=True)
X_poly = interact.fit_transform(X)
assert_array_almost_equal(X_poly, P2[:, [0, 1, 2, 4]])
def test_scaler_1d():
# Test scaling of dataset along single axis
rng = np.random.RandomState(0)
X = rng.randn(5)
X_orig_copy = X.copy()
scaler = StandardScaler()
X_scaled = scaler.fit(X).transform(X, copy=False)
assert_array_almost_equal(X_scaled.mean(axis=0), 0.0)
assert_array_almost_equal(X_scaled.std(axis=0), 1.0)
# check inverse transform
X_scaled_back = scaler.inverse_transform(X_scaled)
assert_array_almost_equal(X_scaled_back, X_orig_copy)
# Test with 1D list
X = [0., 1., 2, 0.4, 1.]
scaler = StandardScaler()
X_scaled = scaler.fit(X).transform(X, copy=False)
assert_array_almost_equal(X_scaled.mean(axis=0), 0.0)
assert_array_almost_equal(X_scaled.std(axis=0), 1.0)
X_scaled = scale(X)
assert_array_almost_equal(X_scaled.mean(axis=0), 0.0)
assert_array_almost_equal(X_scaled.std(axis=0), 1.0)
X = np.ones(5)
assert_array_equal(scale(X, with_mean=False), X)
def test_standard_scaler_numerical_stability():
"""Test numerical stability of scaling"""
# np.log(1e-5) is taken because of its floating point representation
# was empirically found to cause numerical problems with np.mean & np.std.
x = np.zeros(8, dtype=np.float64) + np.log(1e-5, dtype=np.float64)
if LooseVersion(np.__version__) >= LooseVersion('1.9'):
# This does not raise a warning as the number of samples is too low
# to trigger the problem in recent numpy
x_scaled = assert_no_warnings(scale, x)
assert_array_almost_equal(scale(x), np.zeros(8))
else:
w = "standard deviation of the data is probably very close to 0"
x_scaled = assert_warns_message(UserWarning, w, scale, x)
assert_array_almost_equal(x_scaled, np.zeros(8))
# with 2 more samples, the std computation run into numerical issues:
x = np.zeros(10, dtype=np.float64) + np.log(1e-5, dtype=np.float64)
w = "standard deviation of the data is probably very close to 0"
x_scaled = assert_warns_message(UserWarning, w, scale, x)
assert_array_almost_equal(x_scaled, np.zeros(10))
x = np.ones(10, dtype=np.float64) * 1e-100
x_small_scaled = assert_no_warnings(scale, x)
assert_array_almost_equal(x_small_scaled, np.zeros(10))
# Large values can cause (often recoverable) numerical stability issues:
x_big = np.ones(10, dtype=np.float64) * 1e100
w = "Dataset may contain too large values"
x_big_scaled = assert_warns_message(UserWarning, w, scale, x_big)
assert_array_almost_equal(x_big_scaled, np.zeros(10))
assert_array_almost_equal(x_big_scaled, x_small_scaled)
x_big_centered = assert_warns_message(UserWarning, w, scale, x_big,
with_std=False)
assert_array_almost_equal(x_big_centered, np.zeros(10))
assert_array_almost_equal(x_big_centered, x_small_scaled)
def test_scaler_2d_arrays():
# Test scaling of 2d array along first axis
rng = np.random.RandomState(0)
X = rng.randn(4, 5)
X[:, 0] = 0.0 # first feature is always of zero
scaler = StandardScaler()
X_scaled = scaler.fit(X).transform(X, copy=True)
assert_false(np.any(np.isnan(X_scaled)))
assert_array_almost_equal(X_scaled.mean(axis=0), 5 * [0.0])
assert_array_almost_equal(X_scaled.std(axis=0), [0., 1., 1., 1., 1.])
# Check that X has been copied
assert_true(X_scaled is not X)
# check inverse transform
X_scaled_back = scaler.inverse_transform(X_scaled)
assert_true(X_scaled_back is not X)
assert_true(X_scaled_back is not X_scaled)
assert_array_almost_equal(X_scaled_back, X)
X_scaled = scale(X, axis=1, with_std=False)
assert_false(np.any(np.isnan(X_scaled)))
assert_array_almost_equal(X_scaled.mean(axis=1), 4 * [0.0])
X_scaled = scale(X, axis=1, with_std=True)
assert_false(np.any(np.isnan(X_scaled)))
assert_array_almost_equal(X_scaled.mean(axis=1), 4 * [0.0])
assert_array_almost_equal(X_scaled.std(axis=1), 4 * [1.0])
# Check that the data hasn't been modified
assert_true(X_scaled is not X)
X_scaled = scaler.fit(X).transform(X, copy=False)
assert_false(np.any(np.isnan(X_scaled)))
assert_array_almost_equal(X_scaled.mean(axis=0), 5 * [0.0])
assert_array_almost_equal(X_scaled.std(axis=0), [0., 1., 1., 1., 1.])
# Check that X has not been copied
assert_true(X_scaled is X)
X = rng.randn(4, 5)
X[:, 0] = 1.0 # first feature is a constant, non zero feature
scaler = StandardScaler()
X_scaled = scaler.fit(X).transform(X, copy=True)
assert_false(np.any(np.isnan(X_scaled)))
assert_array_almost_equal(X_scaled.mean(axis=0), 5 * [0.0])
assert_array_almost_equal(X_scaled.std(axis=0), [0., 1., 1., 1., 1.])
# Check that X has not been copied
assert_true(X_scaled is not X)
def test_min_max_scaler_iris():
X = iris.data
scaler = MinMaxScaler()
# default params
X_trans = scaler.fit_transform(X)
assert_array_almost_equal(X_trans.min(axis=0), 0)
assert_array_almost_equal(X_trans.min(axis=0), 0)
assert_array_almost_equal(X_trans.max(axis=0), 1)
X_trans_inv = scaler.inverse_transform(X_trans)
assert_array_almost_equal(X, X_trans_inv)
# not default params: min=1, max=2
scaler = MinMaxScaler(feature_range=(1, 2))
X_trans = scaler.fit_transform(X)
assert_array_almost_equal(X_trans.min(axis=0), 1)
assert_array_almost_equal(X_trans.max(axis=0), 2)
X_trans_inv = scaler.inverse_transform(X_trans)
assert_array_almost_equal(X, X_trans_inv)
# min=-.5, max=.6
scaler = MinMaxScaler(feature_range=(-.5, .6))
X_trans = scaler.fit_transform(X)
assert_array_almost_equal(X_trans.min(axis=0), -.5)
assert_array_almost_equal(X_trans.max(axis=0), .6)
X_trans_inv = scaler.inverse_transform(X_trans)
assert_array_almost_equal(X, X_trans_inv)
# raises on invalid range
scaler = MinMaxScaler(feature_range=(2, 1))
assert_raises(ValueError, scaler.fit, X)
def test_min_max_scaler_zero_variance_features():
# Check min max scaler on toy data with zero variance features
X = [[0., 1., +0.5],
[0., 1., -0.1],
[0., 1., +1.1]]
X_new = [[+0., 2., 0.5],
[-1., 1., 0.0],
[+0., 1., 1.5]]
# default params
scaler = MinMaxScaler()
X_trans = scaler.fit_transform(X)
X_expected_0_1 = [[0., 0., 0.5],
[0., 0., 0.0],
[0., 0., 1.0]]
assert_array_almost_equal(X_trans, X_expected_0_1)
X_trans_inv = scaler.inverse_transform(X_trans)
assert_array_almost_equal(X, X_trans_inv)
X_trans_new = scaler.transform(X_new)
X_expected_0_1_new = [[+0., 1., 0.500],
[-1., 0., 0.083],
[+0., 0., 1.333]]
assert_array_almost_equal(X_trans_new, X_expected_0_1_new, decimal=2)
# not default params
scaler = MinMaxScaler(feature_range=(1, 2))
X_trans = scaler.fit_transform(X)
X_expected_1_2 = [[1., 1., 1.5],
[1., 1., 1.0],
[1., 1., 2.0]]
assert_array_almost_equal(X_trans, X_expected_1_2)
def test_min_max_scaler_1d():
# Test scaling of dataset along single axis
rng = np.random.RandomState(0)
X = rng.randn(5)
X_orig_copy = X.copy()
scaler = MinMaxScaler()
X_scaled = scaler.fit(X).transform(X)
assert_array_almost_equal(X_scaled.min(axis=0), 0.0)
assert_array_almost_equal(X_scaled.max(axis=0), 1.0)
# check inverse transform
X_scaled_back = scaler.inverse_transform(X_scaled)
assert_array_almost_equal(X_scaled_back, X_orig_copy)
# Test with 1D list
X = [0., 1., 2, 0.4, 1.]
scaler = MinMaxScaler()
X_scaled = scaler.fit(X).transform(X)
assert_array_almost_equal(X_scaled.min(axis=0), 0.0)
assert_array_almost_equal(X_scaled.max(axis=0), 1.0)
# Constant feature.
X = np.zeros(5)
scaler = MinMaxScaler()
X_scaled = scaler.fit(X).transform(X)
assert_greater_equal(X_scaled.min(), 0.)
assert_less_equal(X_scaled.max(), 1.)
def test_scaler_without_centering():
rng = np.random.RandomState(42)
X = rng.randn(4, 5)
X[:, 0] = 0.0 # first feature is always of zero
X_csr = sparse.csr_matrix(X)
X_csc = sparse.csc_matrix(X)
assert_raises(ValueError, StandardScaler().fit, X_csr)
null_transform = StandardScaler(with_mean=False, with_std=False, copy=True)
X_null = null_transform.fit_transform(X_csr)
assert_array_equal(X_null.data, X_csr.data)
X_orig = null_transform.inverse_transform(X_null)
assert_array_equal(X_orig.data, X_csr.data)
scaler = StandardScaler(with_mean=False).fit(X)
X_scaled = scaler.transform(X, copy=True)
assert_false(np.any(np.isnan(X_scaled)))
scaler_csr = StandardScaler(with_mean=False).fit(X_csr)
X_csr_scaled = scaler_csr.transform(X_csr, copy=True)
assert_false(np.any(np.isnan(X_csr_scaled.data)))
scaler_csc = StandardScaler(with_mean=False).fit(X_csc)
X_csc_scaled = scaler_csr.transform(X_csc, copy=True)
assert_false(np.any(np.isnan(X_csc_scaled.data)))
assert_equal(scaler.mean_, scaler_csr.mean_)
assert_array_almost_equal(scaler.std_, scaler_csr.std_)
assert_equal(scaler.mean_, scaler_csc.mean_)
assert_array_almost_equal(scaler.std_, scaler_csc.std_)
assert_array_almost_equal(
X_scaled.mean(axis=0), [0., -0.01, 2.24, -0.35, -0.78], 2)
assert_array_almost_equal(X_scaled.std(axis=0), [0., 1., 1., 1., 1.])
X_csr_scaled_mean, X_csr_scaled_std = mean_variance_axis(X_csr_scaled, 0)
assert_array_almost_equal(X_csr_scaled_mean, X_scaled.mean(axis=0))
assert_array_almost_equal(X_csr_scaled_std, X_scaled.std(axis=0))
# Check that X has not been modified (copy)
assert_true(X_scaled is not X)
assert_true(X_csr_scaled is not X_csr)
X_scaled_back = scaler.inverse_transform(X_scaled)
assert_true(X_scaled_back is not X)
assert_true(X_scaled_back is not X_scaled)
assert_array_almost_equal(X_scaled_back, X)
X_csr_scaled_back = scaler_csr.inverse_transform(X_csr_scaled)
assert_true(X_csr_scaled_back is not X_csr)
assert_true(X_csr_scaled_back is not X_csr_scaled)
assert_array_almost_equal(X_csr_scaled_back.toarray(), X)
X_csc_scaled_back = scaler_csr.inverse_transform(X_csc_scaled.tocsc())
assert_true(X_csc_scaled_back is not X_csc)
assert_true(X_csc_scaled_back is not X_csc_scaled)
assert_array_almost_equal(X_csc_scaled_back.toarray(), X)
def test_scaler_int():
# test that scaler converts integer input to floating
# for both sparse and dense matrices
rng = np.random.RandomState(42)
X = rng.randint(20, size=(4, 5))
X[:, 0] = 0 # first feature is always of zero
X_csr = sparse.csr_matrix(X)
X_csc = sparse.csc_matrix(X)
null_transform = StandardScaler(with_mean=False, with_std=False, copy=True)
clean_warning_registry()
with warnings.catch_warnings(record=True):
X_null = null_transform.fit_transform(X_csr)
assert_array_equal(X_null.data, X_csr.data)
X_orig = null_transform.inverse_transform(X_null)
assert_array_equal(X_orig.data, X_csr.data)
clean_warning_registry()
with warnings.catch_warnings(record=True):
scaler = StandardScaler(with_mean=False).fit(X)
X_scaled = scaler.transform(X, copy=True)
assert_false(np.any(np.isnan(X_scaled)))
clean_warning_registry()
with warnings.catch_warnings(record=True):
scaler_csr = StandardScaler(with_mean=False).fit(X_csr)
X_csr_scaled = scaler_csr.transform(X_csr, copy=True)
assert_false(np.any(np.isnan(X_csr_scaled.data)))
clean_warning_registry()
with warnings.catch_warnings(record=True):
scaler_csc = StandardScaler(with_mean=False).fit(X_csc)
X_csc_scaled = scaler_csr.transform(X_csc, copy=True)
assert_false(np.any(np.isnan(X_csc_scaled.data)))
assert_equal(scaler.mean_, scaler_csr.mean_)
assert_array_almost_equal(scaler.std_, scaler_csr.std_)
assert_equal(scaler.mean_, scaler_csc.mean_)
assert_array_almost_equal(scaler.std_, scaler_csc.std_)
assert_array_almost_equal(
X_scaled.mean(axis=0),
[0., 1.109, 1.856, 21., 1.559], 2)
assert_array_almost_equal(X_scaled.std(axis=0), [0., 1., 1., 1., 1.])
X_csr_scaled_mean, X_csr_scaled_std = mean_variance_axis(
X_csr_scaled.astype(np.float), 0)
assert_array_almost_equal(X_csr_scaled_mean, X_scaled.mean(axis=0))
assert_array_almost_equal(X_csr_scaled_std, X_scaled.std(axis=0))
# Check that X has not been modified (copy)
assert_true(X_scaled is not X)
assert_true(X_csr_scaled is not X_csr)
X_scaled_back = scaler.inverse_transform(X_scaled)
assert_true(X_scaled_back is not X)
assert_true(X_scaled_back is not X_scaled)
assert_array_almost_equal(X_scaled_back, X)
X_csr_scaled_back = scaler_csr.inverse_transform(X_csr_scaled)
assert_true(X_csr_scaled_back is not X_csr)
assert_true(X_csr_scaled_back is not X_csr_scaled)
assert_array_almost_equal(X_csr_scaled_back.toarray(), X)
X_csc_scaled_back = scaler_csr.inverse_transform(X_csc_scaled.tocsc())
assert_true(X_csc_scaled_back is not X_csc)
assert_true(X_csc_scaled_back is not X_csc_scaled)
assert_array_almost_equal(X_csc_scaled_back.toarray(), X)
def test_scaler_without_copy():
# Check that StandardScaler.fit does not change input
rng = np.random.RandomState(42)
X = rng.randn(4, 5)
X[:, 0] = 0.0 # first feature is always of zero
X_csr = sparse.csr_matrix(X)
X_copy = X.copy()
StandardScaler(copy=False).fit(X)
assert_array_equal(X, X_copy)
X_csr_copy = X_csr.copy()
StandardScaler(with_mean=False, copy=False).fit(X_csr)
assert_array_equal(X_csr.toarray(), X_csr_copy.toarray())
def test_scale_sparse_with_mean_raise_exception():
rng = np.random.RandomState(42)
X = rng.randn(4, 5)
X_csr = sparse.csr_matrix(X)
# check scaling and fit with direct calls on sparse data
assert_raises(ValueError, scale, X_csr, with_mean=True)
assert_raises(ValueError, StandardScaler(with_mean=True).fit, X_csr)
# check transform and inverse_transform after a fit on a dense array
scaler = StandardScaler(with_mean=True).fit(X)
assert_raises(ValueError, scaler.transform, X_csr)
X_transformed_csr = sparse.csr_matrix(scaler.transform(X))
assert_raises(ValueError, scaler.inverse_transform, X_transformed_csr)
def test_scale_input_finiteness_validation():
# Check if non finite inputs raise ValueError
X = [np.nan, 5, 6, 7, 8]
assert_raises_regex(ValueError,
"Input contains NaN, infinity or a value too large",
scale, X)
X = [np.inf, 5, 6, 7, 8]
assert_raises_regex(ValueError,
"Input contains NaN, infinity or a value too large",
scale, X)
def test_scale_function_without_centering():
rng = np.random.RandomState(42)
X = rng.randn(4, 5)
X[:, 0] = 0.0 # first feature is always of zero
X_csr = sparse.csr_matrix(X)
X_scaled = scale(X, with_mean=False)
assert_false(np.any(np.isnan(X_scaled)))
X_csr_scaled = scale(X_csr, with_mean=False)
assert_false(np.any(np.isnan(X_csr_scaled.data)))
# test csc has same outcome
X_csc_scaled = scale(X_csr.tocsc(), with_mean=False)
assert_array_almost_equal(X_scaled, X_csc_scaled.toarray())
# raises value error on axis != 0
assert_raises(ValueError, scale, X_csr, with_mean=False, axis=1)
assert_array_almost_equal(X_scaled.mean(axis=0),
[0., -0.01, 2.24, -0.35, -0.78], 2)
assert_array_almost_equal(X_scaled.std(axis=0), [0., 1., 1., 1., 1.])
# Check that X has not been copied
assert_true(X_scaled is not X)
X_csr_scaled_mean, X_csr_scaled_std = mean_variance_axis(X_csr_scaled, 0)
assert_array_almost_equal(X_csr_scaled_mean, X_scaled.mean(axis=0))
assert_array_almost_equal(X_csr_scaled_std, X_scaled.std(axis=0))
def test_robust_scaler_2d_arrays():
"""Test robust scaling of 2d array along first axis"""
rng = np.random.RandomState(0)
X = rng.randn(4, 5)
X[:, 0] = 0.0 # first feature is always of zero
scaler = RobustScaler()
X_scaled = scaler.fit(X).transform(X)
assert_array_almost_equal(np.median(X_scaled, axis=0), 5 * [0.0])
assert_array_almost_equal(X_scaled.std(axis=0)[0], 0)
def test_robust_scaler_iris():
X = iris.data
scaler = RobustScaler()
X_trans = scaler.fit_transform(X)
assert_array_almost_equal(np.median(X_trans, axis=0), 0)
X_trans_inv = scaler.inverse_transform(X_trans)
assert_array_almost_equal(X, X_trans_inv)
q = np.percentile(X_trans, q=(25, 75), axis=0)
iqr = q[1] - q[0]
assert_array_almost_equal(iqr, 1)
def test_robust_scale_axis1():
X = iris.data
X_trans = robust_scale(X, axis=1)
assert_array_almost_equal(np.median(X_trans, axis=1), 0)
q = np.percentile(X_trans, q=(25, 75), axis=1)
iqr = q[1] - q[0]
assert_array_almost_equal(iqr, 1)
def test_robust_scaler_zero_variance_features():
"""Check RobustScaler on toy data with zero variance features"""
X = [[0., 1., +0.5],
[0., 1., -0.1],
[0., 1., +1.1]]
scaler = RobustScaler()
X_trans = scaler.fit_transform(X)
# NOTE: for such a small sample size, what we expect in the third column
# depends HEAVILY on the method used to calculate quantiles. The values
# here were calculated to fit the quantiles produces by np.percentile
# using numpy 1.9 Calculating quantiles with
# scipy.stats.mstats.scoreatquantile or scipy.stats.mstats.mquantiles
# would yield very different results!
X_expected = [[0., 0., +0.0],
[0., 0., -1.0],
[0., 0., +1.0]]
assert_array_almost_equal(X_trans, X_expected)
X_trans_inv = scaler.inverse_transform(X_trans)
assert_array_almost_equal(X, X_trans_inv)
# make sure new data gets transformed correctly
X_new = [[+0., 2., 0.5],
[-1., 1., 0.0],
[+0., 1., 1.5]]
X_trans_new = scaler.transform(X_new)
X_expected_new = [[+0., 1., +0.],
[-1., 0., -0.83333],
[+0., 0., +1.66667]]
assert_array_almost_equal(X_trans_new, X_expected_new, decimal=3)
def test_maxabs_scaler_zero_variance_features():
"""Check MaxAbsScaler on toy data with zero variance features"""
X = [[0., 1., +0.5],
[0., 1., -0.3],
[0., 1., +1.5],
[0., 0., +0.0]]
scaler = MaxAbsScaler()
X_trans = scaler.fit_transform(X)
X_expected = [[0., 1., 1.0 / 3.0],
[0., 1., -0.2],
[0., 1., 1.0],
[0., 0., 0.0]]
assert_array_almost_equal(X_trans, X_expected)
X_trans_inv = scaler.inverse_transform(X_trans)
assert_array_almost_equal(X, X_trans_inv)
# make sure new data gets transformed correctly
X_new = [[+0., 2., 0.5],
[-1., 1., 0.0],
[+0., 1., 1.5]]
X_trans_new = scaler.transform(X_new)
X_expected_new = [[+0., 2.0, 1.0 / 3.0],
[-1., 1.0, 0.0],
[+0., 1.0, 1.0]]
assert_array_almost_equal(X_trans_new, X_expected_new, decimal=2)
# sparse data
X_csr = sparse.csr_matrix(X)
X_trans = scaler.fit_transform(X_csr)
X_expected = [[0., 1., 1.0 / 3.0],
[0., 1., -0.2],
[0., 1., 1.0],
[0., 0., 0.0]]
assert_array_almost_equal(X_trans.A, X_expected)
X_trans_inv = scaler.inverse_transform(X_trans)
assert_array_almost_equal(X, X_trans_inv.A)
def test_maxabs_scaler_large_negative_value():
"""Check MaxAbsScaler on toy data with a large negative value"""
X = [[0., 1., +0.5, -1.0],
[0., 1., -0.3, -0.5],
[0., 1., -100.0, 0.0],
[0., 0., +0.0, -2.0]]
scaler = MaxAbsScaler()
X_trans = scaler.fit_transform(X)
X_expected = [[0., 1., 0.005, -0.5],
[0., 1., -0.003, -0.25],
[0., 1., -1.0, 0.0],
[0., 0., 0.0, -1.0]]
assert_array_almost_equal(X_trans, X_expected)
def test_warning_scaling_integers():
# Check warning when scaling integer data
X = np.array([[1, 2, 0],
[0, 0, 0]], dtype=np.uint8)
w = "Data with input dtype uint8 was converted to float64"
clean_warning_registry()
assert_warns_message(DataConversionWarning, w, scale, X)
assert_warns_message(DataConversionWarning, w, StandardScaler().fit, X)
assert_warns_message(DataConversionWarning, w, MinMaxScaler().fit, X)
def test_normalizer_l1():
rng = np.random.RandomState(0)
X_dense = rng.randn(4, 5)
X_sparse_unpruned = sparse.csr_matrix(X_dense)
# set the row number 3 to zero
X_dense[3, :] = 0.0
# set the row number 3 to zero without pruning (can happen in real life)
indptr_3 = X_sparse_unpruned.indptr[3]
indptr_4 = X_sparse_unpruned.indptr[4]
X_sparse_unpruned.data[indptr_3:indptr_4] = 0.0
# build the pruned variant using the regular constructor
X_sparse_pruned = sparse.csr_matrix(X_dense)
# check inputs that support the no-copy optim
for X in (X_dense, X_sparse_pruned, X_sparse_unpruned):
normalizer = Normalizer(norm='l1', copy=True)
X_norm = normalizer.transform(X)
assert_true(X_norm is not X)
X_norm1 = toarray(X_norm)
normalizer = Normalizer(norm='l1', copy=False)
X_norm = normalizer.transform(X)
assert_true(X_norm is X)
X_norm2 = toarray(X_norm)
for X_norm in (X_norm1, X_norm2):
row_sums = np.abs(X_norm).sum(axis=1)
for i in range(3):
assert_almost_equal(row_sums[i], 1.0)
assert_almost_equal(row_sums[3], 0.0)
# check input for which copy=False won't prevent a copy
for init in (sparse.coo_matrix, sparse.csc_matrix, sparse.lil_matrix):
X = init(X_dense)
X_norm = normalizer = Normalizer(norm='l2', copy=False).transform(X)
assert_true(X_norm is not X)
assert_true(isinstance(X_norm, sparse.csr_matrix))
X_norm = toarray(X_norm)
for i in range(3):
assert_almost_equal(row_sums[i], 1.0)
assert_almost_equal(la.norm(X_norm[3]), 0.0)
def test_normalizer_l2():
rng = np.random.RandomState(0)
X_dense = rng.randn(4, 5)
X_sparse_unpruned = sparse.csr_matrix(X_dense)
# set the row number 3 to zero
X_dense[3, :] = 0.0
# set the row number 3 to zero without pruning (can happen in real life)
indptr_3 = X_sparse_unpruned.indptr[3]
indptr_4 = X_sparse_unpruned.indptr[4]
X_sparse_unpruned.data[indptr_3:indptr_4] = 0.0
# build the pruned variant using the regular constructor
X_sparse_pruned = sparse.csr_matrix(X_dense)
# check inputs that support the no-copy optim
for X in (X_dense, X_sparse_pruned, X_sparse_unpruned):
normalizer = Normalizer(norm='l2', copy=True)
X_norm1 = normalizer.transform(X)
assert_true(X_norm1 is not X)
X_norm1 = toarray(X_norm1)
normalizer = Normalizer(norm='l2', copy=False)
X_norm2 = normalizer.transform(X)
assert_true(X_norm2 is X)
X_norm2 = toarray(X_norm2)
for X_norm in (X_norm1, X_norm2):
for i in range(3):
assert_almost_equal(la.norm(X_norm[i]), 1.0)
assert_almost_equal(la.norm(X_norm[3]), 0.0)
# check input for which copy=False won't prevent a copy
for init in (sparse.coo_matrix, sparse.csc_matrix, sparse.lil_matrix):
X = init(X_dense)
X_norm = normalizer = Normalizer(norm='l2', copy=False).transform(X)
assert_true(X_norm is not X)
assert_true(isinstance(X_norm, sparse.csr_matrix))
X_norm = toarray(X_norm)
for i in range(3):
assert_almost_equal(la.norm(X_norm[i]), 1.0)
assert_almost_equal(la.norm(X_norm[3]), 0.0)
def test_normalizer_max():
rng = np.random.RandomState(0)
X_dense = rng.randn(4, 5)
X_sparse_unpruned = sparse.csr_matrix(X_dense)
# set the row number 3 to zero
X_dense[3, :] = 0.0
# set the row number 3 to zero without pruning (can happen in real life)
indptr_3 = X_sparse_unpruned.indptr[3]
indptr_4 = X_sparse_unpruned.indptr[4]
X_sparse_unpruned.data[indptr_3:indptr_4] = 0.0
# build the pruned variant using the regular constructor
X_sparse_pruned = sparse.csr_matrix(X_dense)
# check inputs that support the no-copy optim
for X in (X_dense, X_sparse_pruned, X_sparse_unpruned):
normalizer = Normalizer(norm='max', copy=True)
X_norm1 = normalizer.transform(X)
assert_true(X_norm1 is not X)
X_norm1 = toarray(X_norm1)
normalizer = Normalizer(norm='max', copy=False)
X_norm2 = normalizer.transform(X)
assert_true(X_norm2 is X)
X_norm2 = toarray(X_norm2)
for X_norm in (X_norm1, X_norm2):
row_maxs = X_norm.max(axis=1)
for i in range(3):
assert_almost_equal(row_maxs[i], 1.0)
assert_almost_equal(row_maxs[3], 0.0)
# check input for which copy=False won't prevent a copy
for init in (sparse.coo_matrix, sparse.csc_matrix, sparse.lil_matrix):
X = init(X_dense)
X_norm = normalizer = Normalizer(norm='l2', copy=False).transform(X)
assert_true(X_norm is not X)
assert_true(isinstance(X_norm, sparse.csr_matrix))
X_norm = toarray(X_norm)
for i in range(3):
assert_almost_equal(row_maxs[i], 1.0)
assert_almost_equal(la.norm(X_norm[3]), 0.0)
def test_normalize():
# Test normalize function
# Only tests functionality not used by the tests for Normalizer.
X = np.random.RandomState(37).randn(3, 2)
assert_array_equal(normalize(X, copy=False),
normalize(X.T, axis=0, copy=False).T)
assert_raises(ValueError, normalize, [[0]], axis=2)
assert_raises(ValueError, normalize, [[0]], norm='l3')
def test_binarizer():
X_ = np.array([[1, 0, 5], [2, 3, -1]])
for init in (np.array, list, sparse.csr_matrix, sparse.csc_matrix):
X = init(X_.copy())
binarizer = Binarizer(threshold=2.0, copy=True)
X_bin = toarray(binarizer.transform(X))
assert_equal(np.sum(X_bin == 0), 4)
assert_equal(np.sum(X_bin == 1), 2)
X_bin = binarizer.transform(X)
assert_equal(sparse.issparse(X), sparse.issparse(X_bin))
binarizer = Binarizer(copy=True).fit(X)
X_bin = toarray(binarizer.transform(X))
assert_true(X_bin is not X)
assert_equal(np.sum(X_bin == 0), 2)
assert_equal(np.sum(X_bin == 1), 4)
binarizer = Binarizer(copy=True)
X_bin = binarizer.transform(X)
assert_true(X_bin is not X)
X_bin = toarray(X_bin)
assert_equal(np.sum(X_bin == 0), 2)
assert_equal(np.sum(X_bin == 1), 4)
binarizer = Binarizer(copy=False)
X_bin = binarizer.transform(X)
if init is not list:
assert_true(X_bin is X)
X_bin = toarray(X_bin)
assert_equal(np.sum(X_bin == 0), 2)
assert_equal(np.sum(X_bin == 1), 4)
binarizer = Binarizer(threshold=-0.5, copy=True)
for init in (np.array, list):
X = init(X_.copy())
X_bin = toarray(binarizer.transform(X))
assert_equal(np.sum(X_bin == 0), 1)
assert_equal(np.sum(X_bin == 1), 5)
X_bin = binarizer.transform(X)
# Cannot use threshold < 0 for sparse
assert_raises(ValueError, binarizer.transform, sparse.csc_matrix(X))
def test_center_kernel():
# Test that KernelCenterer is equivalent to StandardScaler
# in feature space
rng = np.random.RandomState(0)
X_fit = rng.random_sample((5, 4))
scaler = StandardScaler(with_std=False)
scaler.fit(X_fit)
X_fit_centered = scaler.transform(X_fit)
K_fit = np.dot(X_fit, X_fit.T)
# center fit time matrix
centerer = KernelCenterer()
K_fit_centered = np.dot(X_fit_centered, X_fit_centered.T)
K_fit_centered2 = centerer.fit_transform(K_fit)
assert_array_almost_equal(K_fit_centered, K_fit_centered2)
# center predict time matrix
X_pred = rng.random_sample((2, 4))
K_pred = np.dot(X_pred, X_fit.T)
X_pred_centered = scaler.transform(X_pred)
K_pred_centered = np.dot(X_pred_centered, X_fit_centered.T)
K_pred_centered2 = centerer.transform(K_pred)
assert_array_almost_equal(K_pred_centered, K_pred_centered2)
def test_fit_transform():
rng = np.random.RandomState(0)
X = rng.random_sample((5, 4))
for obj in ((StandardScaler(), Normalizer(), Binarizer())):
X_transformed = obj.fit(X).transform(X)
X_transformed2 = obj.fit_transform(X)
assert_array_equal(X_transformed, X_transformed2)
def test_add_dummy_feature():
X = [[1, 0], [0, 1], [0, 1]]
X = add_dummy_feature(X)
assert_array_equal(X, [[1, 1, 0], [1, 0, 1], [1, 0, 1]])
def test_add_dummy_feature_coo():
X = sparse.coo_matrix([[1, 0], [0, 1], [0, 1]])
X = add_dummy_feature(X)
assert_true(sparse.isspmatrix_coo(X), X)
assert_array_equal(X.toarray(), [[1, 1, 0], [1, 0, 1], [1, 0, 1]])
def test_add_dummy_feature_csc():
X = sparse.csc_matrix([[1, 0], [0, 1], [0, 1]])
X = add_dummy_feature(X)
assert_true(sparse.isspmatrix_csc(X), X)
assert_array_equal(X.toarray(), [[1, 1, 0], [1, 0, 1], [1, 0, 1]])
def test_add_dummy_feature_csr():
X = sparse.csr_matrix([[1, 0], [0, 1], [0, 1]])
X = add_dummy_feature(X)
assert_true(sparse.isspmatrix_csr(X), X)
assert_array_equal(X.toarray(), [[1, 1, 0], [1, 0, 1], [1, 0, 1]])
def test_one_hot_encoder_sparse():
# Test OneHotEncoder's fit and transform.
X = [[3, 2, 1], [0, 1, 1]]
enc = OneHotEncoder()
# discover max values automatically
X_trans = enc.fit_transform(X).toarray()
assert_equal(X_trans.shape, (2, 5))
assert_array_equal(enc.active_features_,
np.where([1, 0, 0, 1, 0, 1, 1, 0, 1])[0])
assert_array_equal(enc.feature_indices_, [0, 4, 7, 9])
# check outcome
assert_array_equal(X_trans,
[[0., 1., 0., 1., 1.],
[1., 0., 1., 0., 1.]])
# max value given as 3
enc = OneHotEncoder(n_values=4)
X_trans = enc.fit_transform(X)
assert_equal(X_trans.shape, (2, 4 * 3))
assert_array_equal(enc.feature_indices_, [0, 4, 8, 12])
# max value given per feature
enc = OneHotEncoder(n_values=[3, 2, 2])
X = [[1, 0, 1], [0, 1, 1]]
X_trans = enc.fit_transform(X)
assert_equal(X_trans.shape, (2, 3 + 2 + 2))
assert_array_equal(enc.n_values_, [3, 2, 2])
# check that testing with larger feature works:
X = np.array([[2, 0, 1], [0, 1, 1]])
enc.transform(X)
# test that an error is raised when out of bounds:
X_too_large = [[0, 2, 1], [0, 1, 1]]
assert_raises(ValueError, enc.transform, X_too_large)
assert_raises(ValueError, OneHotEncoder(n_values=2).fit_transform, X)
# test that error is raised when wrong number of features
assert_raises(ValueError, enc.transform, X[:, :-1])
# test that error is raised when wrong number of features in fit
# with prespecified n_values
assert_raises(ValueError, enc.fit, X[:, :-1])
# test exception on wrong init param
assert_raises(TypeError, OneHotEncoder(n_values=np.int).fit, X)
enc = OneHotEncoder()
# test negative input to fit
assert_raises(ValueError, enc.fit, [[0], [-1]])
# test negative input to transform
enc.fit([[0], [1]])
assert_raises(ValueError, enc.transform, [[0], [-1]])
def test_one_hot_encoder_dense():
# check for sparse=False
X = [[3, 2, 1], [0, 1, 1]]
enc = OneHotEncoder(sparse=False)
# discover max values automatically
X_trans = enc.fit_transform(X)
assert_equal(X_trans.shape, (2, 5))
assert_array_equal(enc.active_features_,
np.where([1, 0, 0, 1, 0, 1, 1, 0, 1])[0])
assert_array_equal(enc.feature_indices_, [0, 4, 7, 9])
# check outcome
assert_array_equal(X_trans,
np.array([[0., 1., 0., 1., 1.],
[1., 0., 1., 0., 1.]]))
def _check_transform_selected(X, X_expected, sel):
for M in (X, sparse.csr_matrix(X)):
Xtr = _transform_selected(M, Binarizer().transform, sel)
assert_array_equal(toarray(Xtr), X_expected)
def test_transform_selected():
X = [[3, 2, 1], [0, 1, 1]]
X_expected = [[1, 2, 1], [0, 1, 1]]
_check_transform_selected(X, X_expected, [0])
_check_transform_selected(X, X_expected, [True, False, False])
X_expected = [[1, 1, 1], [0, 1, 1]]
_check_transform_selected(X, X_expected, [0, 1, 2])
_check_transform_selected(X, X_expected, [True, True, True])
_check_transform_selected(X, X_expected, "all")
_check_transform_selected(X, X, [])
_check_transform_selected(X, X, [False, False, False])
def _run_one_hot(X, X2, cat):
enc = OneHotEncoder(categorical_features=cat)
Xtr = enc.fit_transform(X)
X2tr = enc.transform(X2)
return Xtr, X2tr
def _check_one_hot(X, X2, cat, n_features):
ind = np.where(cat)[0]
# With mask
A, B = _run_one_hot(X, X2, cat)
# With indices
C, D = _run_one_hot(X, X2, ind)
# Check shape
assert_equal(A.shape, (2, n_features))
assert_equal(B.shape, (1, n_features))
assert_equal(C.shape, (2, n_features))
assert_equal(D.shape, (1, n_features))
# Check that mask and indices give the same results
assert_array_equal(toarray(A), toarray(C))
assert_array_equal(toarray(B), toarray(D))
def test_one_hot_encoder_categorical_features():
X = np.array([[3, 2, 1], [0, 1, 1]])
X2 = np.array([[1, 1, 1]])
cat = [True, False, False]
_check_one_hot(X, X2, cat, 4)
# Edge case: all non-categorical
cat = [False, False, False]
_check_one_hot(X, X2, cat, 3)
# Edge case: all categorical
cat = [True, True, True]
_check_one_hot(X, X2, cat, 5)
def test_one_hot_encoder_unknown_transform():
X = np.array([[0, 2, 1], [1, 0, 3], [1, 0, 2]])
y = np.array([[4, 1, 1]])
# Test that one hot encoder raises error for unknown features
# present during transform.
oh = OneHotEncoder(handle_unknown='error')
oh.fit(X)
assert_raises(ValueError, oh.transform, y)
# Test the ignore option, ignores unknown features.
oh = OneHotEncoder(handle_unknown='ignore')
oh.fit(X)
assert_array_equal(
oh.transform(y).toarray(),
np.array([[0., 0., 0., 0., 1., 0., 0.]])
)
# Raise error if handle_unknown is neither ignore or error.
oh = OneHotEncoder(handle_unknown='42')
oh.fit(X)
assert_raises(ValueError, oh.transform, y)
| bsd-3-clause |
ywcui1990/nupic.research | projects/nlp/run_tm_learning.py | 11 | 5601 | #!/usr/bin/env python
# ----------------------------------------------------------------------
# Numenta Platform for Intelligent Computing (NuPIC)
# Copyright (C) 2015, Numenta, Inc. Unless you have purchased from
# Numenta, Inc. a separate commercial license for this software code, the
# following terms and conditions apply:
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero Public License version 3 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the GNU Affero Public License for more details.
#
# You should have received a copy of the GNU Affero Public License
# along with this program. If not, see http://www.gnu.org/licenses.
#
# http://numenta.org/licenses/
# ----------------------------------------------------------------------
"""
Script to run temporal memory on NLP documents
"""
import argparse
from textwrap import TextWrapper
import numpy as np
from matplotlib import pyplot as plt
import matplotlib.patches as mpatches
import nupic
from nupic.data.file_record_stream import FileRecordStream
from htmresearch.frameworks.nlp.classification_model import ClassificationModel
from htmresearch.frameworks.nlp.model_factory import (
createModel, getNetworkConfig)
from htmresearch.support.csv_helper import readDataAndReshuffle
plt.ion()
wrapper = TextWrapper(width=100)
def getTMRegion(network):
tmRegion = None
for region in network.regions.values():
regionInstance = region
if type(regionInstance.getSelf()) is nupic.regions.TPRegion.TPRegion:
tmRegion = regionInstance.getSelf()
return tmRegion
def instantiateModel(args):
"""
Return an instance of the model we will use.
"""
# Some values of K we know work well for this problem for specific model types
kValues = {"keywords": 21, "docfp": 3}
# Create model after setting specific arguments required for this experiment
args.networkConfig = getNetworkConfig(args.networkConfigPath)
args.k = kValues.get(args.modelName, 1)
args.numLabels = 2
model = createModel(**vars(args))
return model
def trainModel(args, model, trainingData, labelRefs):
"""
Train the given model on trainingData. Return the trained model instance.
"""
tmRegion = getTMRegion(model.network)
print
print "=======================Training model on sample text================"
for recordNum, doc in enumerate(trainingData):
document = doc[0]
labels = doc[1]
docId = doc[2]
if args.verbosity > 0:
print
print "Document=", wrapper.fill(document)
print "label=", labelRefs[labels[0]], "id=", docId
model.trainDocument(document, labels, docId)
numActiveCols = tmRegion._tfdr.mmGetTraceActiveColumns().makeCountsTrace().data
numPredictedActiveCells = \
tmRegion._tfdr.mmGetTracePredictedActiveCells().makeCountsTrace().data
if args.verbosity > 0:
print "Word # %s, Avg Active Cols # %s, Avg predicted-active cell # %s " % (
len(numActiveCols),
np.mean(np.array(numActiveCols)),
np.mean(np.array(numPredictedActiveCells))
)
tmRegion._tfdr.mmClearHistory()
return model
def runExperiment(args):
"""
Create model according to args, train on training data, save model,
restore model, test on test data.
"""
args.numLabels = 2
(trainingData, labelRefs, documentCategoryMap,
documentTextMap) = readDataAndReshuffle(args)
# Create model
model = instantiateModel(args)
model = trainModel(args, model, trainingData, labelRefs)
# TODO: Visualize prediction quality
if __name__ == "__main__":
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
parser.add_argument("-c", "--networkConfigPath",
default="data/network_configs/tm_knn_4k_retina.json",
help="Path to JSON specifying the network params.",
type=str)
parser.add_argument("-m", "--modelName",
default="htm",
type=str,
help="Name of model class. Options: [keywords,htm,docfp]")
parser.add_argument("--retinaScaling",
default=1.0,
type=float,
help="Factor by which to scale the Cortical.io retina.")
parser.add_argument("--retina",
default="en_associative_64_univ",
type=str,
help="Name of Cortical.io retina.")
parser.add_argument("--apiKey",
default=None,
type=str,
help="Key for Cortical.io API. If not specified will "
"use the environment variable CORTICAL_API_KEY.")
parser.add_argument("--modelDir",
default="MODELNAME.checkpoint",
help="Model will be saved in this directory.")
parser.add_argument("-v", "--verbosity",
default=1,
type=int,
help="verbosity 0 will print out experiment steps, "
"verbosity 1 will include results, and verbosity > "
"1 will print out preprocessed tokens and kNN "
"inference metrics.")
args = parser.parse_args()
# By default set checkpoint directory name based on model name
if args.modelDir == "MODELNAME.checkpoint":
args.modelDir = args.modelName + ".checkpoint"
print "Save dir: ", args.modelDir
runExperiment(args)
| agpl-3.0 |
hugobowne/scikit-learn | sklearn/utils/testing.py | 4 | 27143 | """Testing utilities."""
# Copyright (c) 2011, 2012
# Authors: Pietro Berkes,
# Andreas Muller
# Mathieu Blondel
# Olivier Grisel
# Arnaud Joly
# Denis Engemann
# Giorgio Patrini
# License: BSD 3 clause
import os
import inspect
import pkgutil
import warnings
import sys
import re
import platform
import struct
import scipy as sp
import scipy.io
from functools import wraps
from operator import itemgetter
try:
# Python 2
from urllib2 import urlopen
from urllib2 import HTTPError
except ImportError:
# Python 3+
from urllib.request import urlopen
from urllib.error import HTTPError
import tempfile
import shutil
import os.path as op
import atexit
# WindowsError only exist on Windows
try:
WindowsError
except NameError:
WindowsError = None
import sklearn
from sklearn.base import BaseEstimator
from sklearn.externals import joblib
# Conveniently import all assertions in one place.
from nose.tools import assert_equal
from nose.tools import assert_not_equal
from nose.tools import assert_true
from nose.tools import assert_false
from nose.tools import assert_raises
from nose.tools import raises
from nose import SkipTest
from nose import with_setup
from numpy.testing import assert_almost_equal
from numpy.testing import assert_array_equal
from numpy.testing import assert_array_almost_equal
from numpy.testing import assert_array_less
from numpy.testing import assert_approx_equal
import numpy as np
from sklearn.base import (ClassifierMixin, RegressorMixin, TransformerMixin,
ClusterMixin)
from sklearn.cluster import DBSCAN
__all__ = ["assert_equal", "assert_not_equal", "assert_raises",
"assert_raises_regexp", "raises", "with_setup", "assert_true",
"assert_false", "assert_almost_equal", "assert_array_equal",
"assert_array_almost_equal", "assert_array_less",
"assert_less", "assert_less_equal",
"assert_greater", "assert_greater_equal",
"assert_approx_equal"]
try:
from nose.tools import assert_in, assert_not_in
except ImportError:
# Nose < 1.0.0
def assert_in(x, container):
assert_true(x in container, msg="%r in %r" % (x, container))
def assert_not_in(x, container):
assert_false(x in container, msg="%r in %r" % (x, container))
try:
from nose.tools import assert_raises_regex
except ImportError:
# for Python 2
def assert_raises_regex(expected_exception, expected_regexp,
callable_obj=None, *args, **kwargs):
"""Helper function to check for message patterns in exceptions"""
not_raised = False
try:
callable_obj(*args, **kwargs)
not_raised = True
except expected_exception as e:
error_message = str(e)
if not re.compile(expected_regexp).search(error_message):
raise AssertionError("Error message should match pattern "
"%r. %r does not." %
(expected_regexp, error_message))
if not_raised:
raise AssertionError("%s not raised by %s" %
(expected_exception.__name__,
callable_obj.__name__))
# assert_raises_regexp is deprecated in Python 3.4 in favor of
# assert_raises_regex but lets keep the backward compat in scikit-learn with
# the old name for now
assert_raises_regexp = assert_raises_regex
def _assert_less(a, b, msg=None):
message = "%r is not lower than %r" % (a, b)
if msg is not None:
message += ": " + msg
assert a < b, message
def _assert_greater(a, b, msg=None):
message = "%r is not greater than %r" % (a, b)
if msg is not None:
message += ": " + msg
assert a > b, message
def assert_less_equal(a, b, msg=None):
message = "%r is not lower than or equal to %r" % (a, b)
if msg is not None:
message += ": " + msg
assert a <= b, message
def assert_greater_equal(a, b, msg=None):
message = "%r is not greater than or equal to %r" % (a, b)
if msg is not None:
message += ": " + msg
assert a >= b, message
def assert_warns(warning_class, func, *args, **kw):
"""Test that a certain warning occurs.
Parameters
----------
warning_class : the warning class
The class to test for, e.g. UserWarning.
func : callable
Calable object to trigger warnings.
*args : the positional arguments to `func`.
**kw : the keyword arguments to `func`
Returns
-------
result : the return value of `func`
"""
# very important to avoid uncontrolled state propagation
clean_warning_registry()
with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered.
warnings.simplefilter("always")
# Trigger a warning.
result = func(*args, **kw)
if hasattr(np, 'VisibleDeprecationWarning'):
# Filter out numpy-specific warnings in numpy >= 1.9
w = [e for e in w
if e.category is not np.VisibleDeprecationWarning]
# Verify some things
if not len(w) > 0:
raise AssertionError("No warning raised when calling %s"
% func.__name__)
found = any(warning.category is warning_class for warning in w)
if not found:
raise AssertionError("%s did not give warning: %s( is %s)"
% (func.__name__, warning_class, w))
return result
def assert_warns_message(warning_class, message, func, *args, **kw):
# very important to avoid uncontrolled state propagation
"""Test that a certain warning occurs and with a certain message.
Parameters
----------
warning_class : the warning class
The class to test for, e.g. UserWarning.
message : str | callable
The entire message or a substring to test for. If callable,
it takes a string as argument and will trigger an assertion error
if it returns `False`.
func : callable
Calable object to trigger warnings.
*args : the positional arguments to `func`.
**kw : the keyword arguments to `func`.
Returns
-------
result : the return value of `func`
"""
clean_warning_registry()
with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered.
warnings.simplefilter("always")
if hasattr(np, 'VisibleDeprecationWarning'):
# Let's not catch the numpy internal DeprecationWarnings
warnings.simplefilter('ignore', np.VisibleDeprecationWarning)
# Trigger a warning.
result = func(*args, **kw)
# Verify some things
if not len(w) > 0:
raise AssertionError("No warning raised when calling %s"
% func.__name__)
found = [issubclass(warning.category, warning_class) for warning in w]
if not any(found):
raise AssertionError("No warning raised for %s with class "
"%s"
% (func.__name__, warning_class))
message_found = False
# Checks the message of all warnings belong to warning_class
for index in [i for i, x in enumerate(found) if x]:
# substring will match, the entire message with typo won't
msg = w[index].message # For Python 3 compatibility
msg = str(msg.args[0] if hasattr(msg, 'args') else msg)
if callable(message): # add support for certain tests
check_in_message = message
else:
check_in_message = lambda msg: message in msg
if check_in_message(msg):
message_found = True
break
if not message_found:
raise AssertionError("Did not receive the message you expected "
"('%s') for <%s>, got: '%s'"
% (message, func.__name__, msg))
return result
# To remove when we support numpy 1.7
def assert_no_warnings(func, *args, **kw):
# XXX: once we may depend on python >= 2.6, this can be replaced by the
# warnings module context manager.
# very important to avoid uncontrolled state propagation
clean_warning_registry()
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
result = func(*args, **kw)
if hasattr(np, 'VisibleDeprecationWarning'):
# Filter out numpy-specific warnings in numpy >= 1.9
w = [e for e in w
if e.category is not np.VisibleDeprecationWarning]
if len(w) > 0:
raise AssertionError("Got warnings when calling %s: %s"
% (func.__name__, w))
return result
def ignore_warnings(obj=None):
""" Context manager and decorator to ignore warnings
Note. Using this (in both variants) will clear all warnings
from all python modules loaded. In case you need to test
cross-module-warning-logging this is not your tool of choice.
Examples
--------
>>> with ignore_warnings():
... warnings.warn('buhuhuhu')
>>> def nasty_warn():
... warnings.warn('buhuhuhu')
... print(42)
>>> ignore_warnings(nasty_warn)()
42
"""
if callable(obj):
return _ignore_warnings(obj)
else:
return _IgnoreWarnings()
def _ignore_warnings(fn):
"""Decorator to catch and hide warnings without visual nesting"""
@wraps(fn)
def wrapper(*args, **kwargs):
# very important to avoid uncontrolled state propagation
clean_warning_registry()
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
return fn(*args, **kwargs)
w[:] = []
return wrapper
class _IgnoreWarnings(object):
"""Improved and simplified Python warnings context manager
Copied from Python 2.7.5 and modified as required.
"""
def __init__(self):
"""
Parameters
==========
category : warning class
The category to filter. Defaults to Warning. If None,
all categories will be muted.
"""
self._record = True
self._module = sys.modules['warnings']
self._entered = False
self.log = []
def __repr__(self):
args = []
if self._record:
args.append("record=True")
if self._module is not sys.modules['warnings']:
args.append("module=%r" % self._module)
name = type(self).__name__
return "%s(%s)" % (name, ", ".join(args))
def __enter__(self):
clean_warning_registry() # be safe and not propagate state + chaos
warnings.simplefilter('always')
if self._entered:
raise RuntimeError("Cannot enter %r twice" % self)
self._entered = True
self._filters = self._module.filters
self._module.filters = self._filters[:]
self._showwarning = self._module.showwarning
if self._record:
self.log = []
def showwarning(*args, **kwargs):
self.log.append(warnings.WarningMessage(*args, **kwargs))
self._module.showwarning = showwarning
return self.log
else:
return None
def __exit__(self, *exc_info):
if not self._entered:
raise RuntimeError("Cannot exit %r without entering first" % self)
self._module.filters = self._filters
self._module.showwarning = self._showwarning
self.log[:] = []
clean_warning_registry() # be safe and not propagate state + chaos
try:
from nose.tools import assert_less
except ImportError:
assert_less = _assert_less
try:
from nose.tools import assert_greater
except ImportError:
assert_greater = _assert_greater
def _assert_allclose(actual, desired, rtol=1e-7, atol=0,
err_msg='', verbose=True):
actual, desired = np.asanyarray(actual), np.asanyarray(desired)
if np.allclose(actual, desired, rtol=rtol, atol=atol):
return
msg = ('Array not equal to tolerance rtol=%g, atol=%g: '
'actual %s, desired %s') % (rtol, atol, actual, desired)
raise AssertionError(msg)
if hasattr(np.testing, 'assert_allclose'):
assert_allclose = np.testing.assert_allclose
else:
assert_allclose = _assert_allclose
def assert_raise_message(exceptions, message, function, *args, **kwargs):
"""Helper function to test error messages in exceptions
Parameters
----------
exceptions : exception or tuple of exception
Name of the estimator
func : callable
Calable object to raise error
*args : the positional arguments to `func`.
**kw : the keyword arguments to `func`
"""
try:
function(*args, **kwargs)
except exceptions as e:
error_message = str(e)
if message not in error_message:
raise AssertionError("Error message does not include the expected"
" string: %r. Observed error message: %r" %
(message, error_message))
else:
# concatenate exception names
if isinstance(exceptions, tuple):
names = " or ".join(e.__name__ for e in exceptions)
else:
names = exceptions.__name__
raise AssertionError("%s not raised by %s" %
(names, function.__name__))
def fake_mldata(columns_dict, dataname, matfile, ordering=None):
"""Create a fake mldata data set.
Parameters
----------
columns_dict : dict, keys=str, values=ndarray
Contains data as columns_dict[column_name] = array of data.
dataname : string
Name of data set.
matfile : string or file object
The file name string or the file-like object of the output file.
ordering : list, default None
List of column_names, determines the ordering in the data set.
Notes
-----
This function transposes all arrays, while fetch_mldata only transposes
'data', keep that into account in the tests.
"""
datasets = dict(columns_dict)
# transpose all variables
for name in datasets:
datasets[name] = datasets[name].T
if ordering is None:
ordering = sorted(list(datasets.keys()))
# NOTE: setting up this array is tricky, because of the way Matlab
# re-packages 1D arrays
datasets['mldata_descr_ordering'] = sp.empty((1, len(ordering)),
dtype='object')
for i, name in enumerate(ordering):
datasets['mldata_descr_ordering'][0, i] = name
scipy.io.savemat(matfile, datasets, oned_as='column')
class mock_mldata_urlopen(object):
def __init__(self, mock_datasets):
"""Object that mocks the urlopen function to fake requests to mldata.
`mock_datasets` is a dictionary of {dataset_name: data_dict}, or
{dataset_name: (data_dict, ordering).
`data_dict` itself is a dictionary of {column_name: data_array},
and `ordering` is a list of column_names to determine the ordering
in the data set (see `fake_mldata` for details).
When requesting a dataset with a name that is in mock_datasets,
this object creates a fake dataset in a StringIO object and
returns it. Otherwise, it raises an HTTPError.
"""
self.mock_datasets = mock_datasets
def __call__(self, urlname):
dataset_name = urlname.split('/')[-1]
if dataset_name in self.mock_datasets:
resource_name = '_' + dataset_name
from io import BytesIO
matfile = BytesIO()
dataset = self.mock_datasets[dataset_name]
ordering = None
if isinstance(dataset, tuple):
dataset, ordering = dataset
fake_mldata(dataset, resource_name, matfile, ordering)
matfile.seek(0)
return matfile
else:
raise HTTPError(urlname, 404, dataset_name + " is not available",
[], None)
def install_mldata_mock(mock_datasets):
# Lazy import to avoid mutually recursive imports
from sklearn import datasets
datasets.mldata.urlopen = mock_mldata_urlopen(mock_datasets)
def uninstall_mldata_mock():
# Lazy import to avoid mutually recursive imports
from sklearn import datasets
datasets.mldata.urlopen = urlopen
# Meta estimators need another estimator to be instantiated.
META_ESTIMATORS = ["OneVsOneClassifier", "MultiOutputRegressor",
"OutputCodeClassifier", "OneVsRestClassifier", "RFE",
"RFECV", "BaseEnsemble"]
# estimators that there is no way to default-construct sensibly
OTHER = ["Pipeline", "FeatureUnion", "GridSearchCV", "RandomizedSearchCV",
"SelectFromModel"]
# some trange ones
DONT_TEST = ['SparseCoder', 'EllipticEnvelope', 'DictVectorizer',
'LabelBinarizer', 'LabelEncoder',
'MultiLabelBinarizer', 'TfidfTransformer',
'TfidfVectorizer', 'IsotonicRegression',
'OneHotEncoder', 'RandomTreesEmbedding',
'FeatureHasher', 'DummyClassifier', 'DummyRegressor',
'TruncatedSVD', 'PolynomialFeatures',
'GaussianRandomProjectionHash', 'HashingVectorizer',
'CheckingClassifier', 'PatchExtractor', 'CountVectorizer',
# GradientBoosting base estimators, maybe should
# exclude them in another way
'ZeroEstimator', 'ScaledLogOddsEstimator',
'QuantileEstimator', 'MeanEstimator',
'LogOddsEstimator', 'PriorProbabilityEstimator',
'_SigmoidCalibration', 'VotingClassifier']
def all_estimators(include_meta_estimators=False,
include_other=False, type_filter=None,
include_dont_test=False):
"""Get a list of all estimators from sklearn.
This function crawls the module and gets all classes that inherit
from BaseEstimator. Classes that are defined in test-modules are not
included.
By default meta_estimators such as GridSearchCV are also not included.
Parameters
----------
include_meta_estimators : boolean, default=False
Whether to include meta-estimators that can be constructed using
an estimator as their first argument. These are currently
BaseEnsemble, OneVsOneClassifier, OutputCodeClassifier,
OneVsRestClassifier, RFE, RFECV.
include_other : boolean, default=False
Wether to include meta-estimators that are somehow special and can
not be default-constructed sensibly. These are currently
Pipeline, FeatureUnion and GridSearchCV
include_dont_test : boolean, default=False
Whether to include "special" label estimator or test processors.
type_filter : string, list of string, or None, default=None
Which kind of estimators should be returned. If None, no filter is
applied and all estimators are returned. Possible values are
'classifier', 'regressor', 'cluster' and 'transformer' to get
estimators only of these specific types, or a list of these to
get the estimators that fit at least one of the types.
Returns
-------
estimators : list of tuples
List of (name, class), where ``name`` is the class name as string
and ``class`` is the actuall type of the class.
"""
def is_abstract(c):
if not(hasattr(c, '__abstractmethods__')):
return False
if not len(c.__abstractmethods__):
return False
return True
all_classes = []
# get parent folder
path = sklearn.__path__
for importer, modname, ispkg in pkgutil.walk_packages(
path=path, prefix='sklearn.', onerror=lambda x: None):
if (".tests." in modname):
continue
module = __import__(modname, fromlist="dummy")
classes = inspect.getmembers(module, inspect.isclass)
all_classes.extend(classes)
all_classes = set(all_classes)
estimators = [c for c in all_classes
if (issubclass(c[1], BaseEstimator)
and c[0] != 'BaseEstimator')]
# get rid of abstract base classes
estimators = [c for c in estimators if not is_abstract(c[1])]
if not include_dont_test:
estimators = [c for c in estimators if not c[0] in DONT_TEST]
if not include_other:
estimators = [c for c in estimators if not c[0] in OTHER]
# possibly get rid of meta estimators
if not include_meta_estimators:
estimators = [c for c in estimators if not c[0] in META_ESTIMATORS]
if type_filter is not None:
if not isinstance(type_filter, list):
type_filter = [type_filter]
else:
type_filter = list(type_filter) # copy
filtered_estimators = []
filters = {'classifier': ClassifierMixin,
'regressor': RegressorMixin,
'transformer': TransformerMixin,
'cluster': ClusterMixin}
for name, mixin in filters.items():
if name in type_filter:
type_filter.remove(name)
filtered_estimators.extend([est for est in estimators
if issubclass(est[1], mixin)])
estimators = filtered_estimators
if type_filter:
raise ValueError("Parameter type_filter must be 'classifier', "
"'regressor', 'transformer', 'cluster' or None, got"
" %s." % repr(type_filter))
# drop duplicates, sort for reproducibility
# itemgetter is used to ensure the sort does not extend to the 2nd item of
# the tuple
return sorted(set(estimators), key=itemgetter(0))
def set_random_state(estimator, random_state=0):
"""Set random state of an estimator if it has the `random_state` param.
Classes for whom random_state is deprecated are ignored. Currently DBSCAN
is one such class.
"""
if isinstance(estimator, DBSCAN):
return
if "random_state" in estimator.get_params():
estimator.set_params(random_state=random_state)
def if_matplotlib(func):
"""Test decorator that skips test if matplotlib not installed. """
@wraps(func)
def run_test(*args, **kwargs):
try:
import matplotlib
matplotlib.use('Agg', warn=False)
# this fails if no $DISPLAY specified
import matplotlib.pyplot as plt
plt.figure()
except ImportError:
raise SkipTest('Matplotlib not available.')
else:
return func(*args, **kwargs)
return run_test
def skip_if_32bit(func):
"""Test decorator that skips tests on 32bit platforms."""
@wraps(func)
def run_test(*args, **kwargs):
bits = 8 * struct.calcsize("P")
if bits == 32:
raise SkipTest('Test skipped on 32bit platforms.')
else:
return func(*args, **kwargs)
return run_test
def if_not_mac_os(versions=('10.7', '10.8', '10.9'),
message='Multi-process bug in Mac OS X >= 10.7 '
'(see issue #636)'):
"""Test decorator that skips test if OS is Mac OS X and its
major version is one of ``versions``.
"""
warnings.warn("if_not_mac_os is deprecated in 0.17 and will be removed"
" in 0.19: use the safer and more generic"
" if_safe_multiprocessing_with_blas instead",
DeprecationWarning)
mac_version, _, _ = platform.mac_ver()
skip = '.'.join(mac_version.split('.')[:2]) in versions
def decorator(func):
if skip:
@wraps(func)
def func(*args, **kwargs):
raise SkipTest(message)
return func
return decorator
def if_safe_multiprocessing_with_blas(func):
"""Decorator for tests involving both BLAS calls and multiprocessing
Under POSIX (e.g. Linux or OSX), using multiprocessing in conjunction with
some implementation of BLAS (or other libraries that manage an internal
posix thread pool) can cause a crash or a freeze of the Python process.
In practice all known packaged distributions (from Linux distros or
Anaconda) of BLAS under Linux seems to be safe. So we this problem seems to
only impact OSX users.
This wrapper makes it possible to skip tests that can possibly cause
this crash under OS X with.
Under Python 3.4+ it is possible to use the `forkserver` start method
for multiprocessing to avoid this issue. However it can cause pickling
errors on interactively defined functions. It therefore not enabled by
default.
"""
@wraps(func)
def run_test(*args, **kwargs):
if sys.platform == 'darwin':
raise SkipTest(
"Possible multi-process bug with some BLAS")
return func(*args, **kwargs)
return run_test
def clean_warning_registry():
"""Safe way to reset warnings """
warnings.resetwarnings()
reg = "__warningregistry__"
for mod_name, mod in list(sys.modules.items()):
if 'six.moves' in mod_name:
continue
if hasattr(mod, reg):
getattr(mod, reg).clear()
def check_skip_network():
if int(os.environ.get('SKLEARN_SKIP_NETWORK_TESTS', 0)):
raise SkipTest("Text tutorial requires large dataset download")
def check_skip_travis():
"""Skip test if being run on Travis."""
if os.environ.get('TRAVIS') == "true":
raise SkipTest("This test needs to be skipped on Travis")
def _delete_folder(folder_path, warn=False):
"""Utility function to cleanup a temporary folder if still existing.
Copy from joblib.pool (for independence)"""
try:
if os.path.exists(folder_path):
# This can fail under windows,
# but will succeed when called by atexit
shutil.rmtree(folder_path)
except WindowsError:
if warn:
warnings.warn("Could not delete temporary folder %s" % folder_path)
class TempMemmap(object):
def __init__(self, data, mmap_mode='r'):
self.temp_folder = tempfile.mkdtemp(prefix='sklearn_testing_')
self.mmap_mode = mmap_mode
self.data = data
def __enter__(self):
fpath = op.join(self.temp_folder, 'data.pkl')
joblib.dump(self.data, fpath)
data_read_only = joblib.load(fpath, mmap_mode=self.mmap_mode)
atexit.register(lambda: _delete_folder(self.temp_folder, warn=True))
return data_read_only
def __exit__(self, exc_type, exc_val, exc_tb):
_delete_folder(self.temp_folder)
with_network = with_setup(check_skip_network)
with_travis = with_setup(check_skip_travis)
| bsd-3-clause |
Gorbagzog/StageIAP | MCMC_SHMR_Candels.py | 1 | 25461 | #!/usr/bin/env python3
# -*-coding:Utf-8 -*
"""Use MCMC to find the stellar mass halo mass relation.
Based on the Behroozi et al 2010 paper.
Use a parametrization of the SHMR, plus a given HMF to find the expected SMF and compare it
to the observed SMF with its uncertainties using a likelihod maximisation.
Started on december 18th by Louis Legrand at IAP and IAS.
"""
import numpy as np
import matplotlib.pyplot as plt
import sys
import emcee
from astropy.cosmology import LambdaCDM
import scipy.optimize as op
from scipy import signal
import corner
from getdist import plots, MCSamples
import time
def load_smf():
# Code is copied from IaryDavidzonSMF.py as of 12 june
# redshifts of the Candels+15 data
global redshifts
global numzbin
redshifts = np.array([3.5, 4.5, 5.5, 6.5, 7.5])
numzbin = np.size(redshifts)-1
global smf_candels
smf_candels = []
for i in range(numzbin):
smf_candels.append(np.loadtxt(
# Select the SMFs to use : JEWELS or v2
# '../Data/Candels/grazian15_68CL_z' + str(i+4) + '_JEWELS.txt')
'../Data/Candels/grazian15_68CL_v2_z' + str(i+4) + '.txt')
)
"""Adapt SMF to match the Bolshoi-Planck Cosmology"""
# Bolshoi-Planck cosmo : (flat LCMD)
# Om = 0.3089, Ol = 0.6911, Ob = 0.0486, h = 0.6774, s8 = 0.8159, ns = 0.9667
BP_Cosmo = LambdaCDM(H0=67.74, Om0=0.3089, Ode0=0.6911)
# CANDELS+17 SMF cosmo : (flat LCDM) (same as Davidzon17_COSMO)
# Om = 0.3, Ol = 0.7, h=0.7
D17_Cosmo = LambdaCDM(H0=70, Om0=0.3, Ode0=0.7)
for i in range(numzbin):
# Correction of the comoving Volume :
VmaxD17 = D17_Cosmo.comoving_volume(redshifts[i+1]) - D17_Cosmo.comoving_volume(redshifts[i])
VmaxBP = BP_Cosmo.comoving_volume(redshifts[i+1]) - BP_Cosmo.comoving_volume(redshifts[i])
# VmaxD17 = get_Vmax_mod.main(redshifts[i], redshifts[i+1], cosmo=[70, 0.3, 0.7])
# VmaxBP = get_Vmax_mod.main(redshifts[i], redshifts[i+1], cosmo=[67.74, 0.3089, 0.6911])
# Add the log, equivalent to multiply by VmaxD17/VmaxBP
smf_candels[i][:, 1] = smf_candels[i][:, 1] + np.log10(VmaxD17/VmaxBP)
smf_candels[i][:, 2] = smf_candels[i][:, 2] + np.log10(VmaxD17/VmaxBP)
smf_candels[i][:, 3] = smf_candels[i][:, 3] + np.log10(VmaxD17/VmaxBP)
# Correction of the measured stellar mass
# Equivalent to multiply by (BP_Cosmo.H0/D17_Cosmo.H0)**-2
smf_candels[i][:, 0] = smf_candels[i][:, 0] - 2 * np.log10(BP_Cosmo.H0/D17_Cosmo.H0)
def load_hmf():
"""Load HMF from Bolshoi Planck simulation"""
# redshifts of the BolshoiPlanck files
redshift_haloes = np.arange(0, 10, step=0.1)
numredshift_haloes = np.size(redshift_haloes)
"""Definition of hmf_bolshoi columns :
hmf_bolshoi[redshift][:,0] = Log10(mass) [Msun]
hmf_bolshoi[redshift][:,1] = Log10(cen_mf), ie central haloes mass function
(density) [1/Mpc^3]
hmf_bolshoi[redshift][:,2] = Log10(all_macc_mf), ie all haloes mass function
(density) [1/Mpc^3]
"""
global hmf_bolshoi
hmf_bolshoi_tot = []
for i in range(numredshift_haloes):
hmf_bolshoi_tot.append(
np.loadtxt('../Data/HMFBolshoiPlanck/mf_planck/mf_planck_z' +
'{:4.3f}'.format(redshift_haloes[i]) + '_mvir.dat'))
"""Select the redhifts slices that matches the slices of Iary"""
global redshift_id_selec
redshift_id_selec = np.empty(numzbin)
for i in range(numzbin):
redshift_id_selec[i] = np.argmin(
np.abs(redshift_haloes - (redshifts[i] + redshifts[i + 1]) / 2))
redshift_id_selec = redshift_id_selec.astype(int)
print('Redshifts of Iari SMFs : ' + str((redshifts[:-1] + redshifts[1:]) / 2))
print('Closest redshifts for Bolshoi HMFs : '
+ str(redshift_haloes[redshift_id_selec]))
hmf_bolshoi = []
for i in redshift_id_selec:
hmf_bolshoi.append(hmf_bolshoi_tot[i])
"""Function definitions for computation of the theroretical SFM phi_true"""
def logMh(logMs, M1, Ms0, beta, delta, gamma):
# SM-HM relation
return M1 + beta*(logMs - Ms0) + (10 ** (delta * (logMs - Ms0))) / (1 + (10 ** (-gamma * (logMs - Ms0)))) - 0.5
# Ms = 10**logMs
# logMh = M1 + beta * np.log10(Ms / 10**Ms0) + (Ms / 10**Ms0)**delta / (1 + (Ms / 10**Ms0)**(-gamma)) - 0.5
# return logMh
def log_phi_direct(logMs, idx_z, M1, Ms0, beta, delta, gamma):
# SMF obtained from the SM-HM relation and the HMF
epsilon = 0.0001
log_Mh1 = logMh(logMs, M1, Ms0, beta, delta, gamma)
log_Mh2 = logMh(logMs + epsilon, M1, Ms0, beta, delta, gamma)
# print(logMs)
# print(log_Mh1, log_Mh2)
# index_Mh = np.argmin(np.abs(hmf_bolshoi[idx_z][:, 0] - log_Mh1))
# Select the index of the HMF corresponing to the halo masses
index_Mh = np.argmin(
np.abs(
np.tile(hmf_bolshoi[idx_z][:, 0], (len(log_Mh1), 1)) -
np.transpose(np.tile(log_Mh1, (len(hmf_bolshoi[idx_z][:, 0]), 1)))
), axis=1)
# print(np.tile(hmf_bolshoi[idx_z][:, 0], (len(log_Mh1), 1)))
# print(np.transpose(np.tile(log_Mh1, (len(hmf_bolshoi[idx_z][:, 0]), 1))))
log_phidirect = hmf_bolshoi[idx_z][index_Mh, 2] + np.log10((log_Mh2 - log_Mh1)/epsilon)
# print(np.log10((log_Mh2 - log_Mh1)/epsilon))
# Keep only points where the halo mass is defined in the HMF
log_phidirect[log_Mh1 > hmf_bolshoi[idx_z][-1, 0]] = -1000
log_phidirect[log_Mh1 < hmf_bolshoi[idx_z][0, 0]] = -1000
# print(log_phidirect)
# print(hmf_bolshoi[idx_z][index_Mh, 2])
# print(log_phidirect)
return log_phidirect
def log_phi_true(logMs, idx_z, M1, Ms0, beta, delta, gamma, ksi):
# Use the approximation of the convolution defined in Behroozi et al 2010 equation (3)
epsilon = 0.01 * logMs
logphi1 = log_phi_direct(logMs, idx_z, M1, Ms0, beta, delta, gamma)
logphi2 = log_phi_direct(logMs + epsilon, idx_z, M1, Ms0, beta, delta, gamma)
logphitrue = logphi1 + ksi**2 / 2 * np.log(10) * ((logphi2 - logphi1)/epsilon)**2
return logphitrue
# def phi_expect(z1, z2, logMs, M1, Ms0, beta, delta, gamma, ksi):
# # Take into account that the observed SMF is for a range of redshift
# numpoints = 10
# redshifts = np.linspace(z1, z2, num=numpoints)
# top = 0
# bot = 0
# for i in range(numpoints - 1):
# dVc = BP_Cosmo.comoving_volume(redshifts[i+1]) - BP_Cosmo.comoving_volume(redshifts[i])
# top += phi_true(redshifts[i], logMs, M1, Ms0, beta, delta, gamma, ksi) * dVc
# bot += dVc
# return top/bot
def chi2(idx_z, M1, Ms0, beta, delta, gamma, ksi):
# return the chi**2 between the observed and the expected SMF
# select = np.where(np.logical_and(
# smf_candels[idx_z][:, 1] > -6, # select points where the smf is defined
# smf_candels[idx_z][:, 3] < 900))[0] # select points where the error bar is defined
select = np.where(smf_candels[idx_z][:, 1] > -6) # select points where the smf is defined
# We choose to limit the fit only fro abundances higher than 10**-6
logMs = smf_candels[idx_z][select, 0]
pred = log_phi_true(logMs, idx_z, M1, Ms0, beta, delta, gamma, ksi)
chi2 = np.sum(
((pred -
#smf_candels[idx_z][select, 1]) / ((smf_candels[idx_z][select, 3] + smf_candels[idx_z][select, 2])/2))**2
smf_candels[idx_z][select, 1]) / smf_candels[idx_z][select, 2])**2
)
return chi2
def chi2_noksi(idx_z, M1, Ms0, beta, delta, gamma):
# return the chi**2 between the observed and the expected SMF
# select = np.where(np.logical_and(
# smf_candels[idx_z][:, 1] > -6, # select points where the smf is defined
# smf_candels[idx_z][:, 3] < 900))[0] # select points where the error bar is defined
select = np.where(smf_candels[idx_z][:, 1] > -10) # select points where the smf is defined
# We choose to limit the fit only fro abundances higher than 10**-6
logMs = smf_candels[idx_z][select, 0]
pred = log_phi_direct(logMs, idx_z, M1, Ms0, beta, delta, gamma)
chi2 = np.sum(
((pred -
# When using the VmaxFit2D (give the bands and not the sigma)
smf_candels[idx_z][select, 1]) / ((smf_candels[idx_z][select, 3] - smf_candels[idx_z][select, 2])/2))**2
)
# print( (pred - smf_candels[idx_z][select, 1]) / ((smf_candels[idx_z][select, 3] + smf_candels[idx_z][select, 2])/2))
return chi2
# def loglike(theta, idx_z):
# # return the likelihood
# # print(theta)
# # bouds for the idx_z = 0
# M1, Ms0, beta, delta, gamma, ksi = theta[:]
# if beta < 0.1 or delta < 0.1 or gamma < 0:
# return -np.inf
# if beta > 1 or delta > 1 or gamma > 3:
# return -np.inf
# if M1 < 11 or M1 > 13 or Ms0 < 10 or Ms0 > 12:
# return -np.inf
# if ksi < 0 or ksi > 1:
# return -np.inf
# else:
# return -chi2(idx_z, M1, Ms0, beta, delta, gamma, ksi)/2
def loglike(theta, idx_z):
# return the likelihood
# bounds for the idx_z = 1
M1, Ms0, beta, delta, gamma, ksi = theta[:]
if beta < 0.3 or delta < 0.5 or gamma < 1:
return -np.inf
if beta > 0.6 or delta > 0.7 or gamma > 2.7:
return -np.inf
if M1 < 12 or M1 > 13 or Ms0 < 10 or Ms0 > 12:
return -np.inf
if ksi < 0 or ksi > 1:
return -np.inf
else:
return -chi2(idx_z, M1, Ms0, beta, delta, gamma, ksi)/2
def loglike_noksi(theta, idx_z):
# return the likelihood for a fixed ksi
# print(theta)
M1, Ms0, beta, delta, gamma = theta[:]
if idx_z < 5 :
if beta < 0 or delta < 0 or gamma < 0:
return -np.inf
if beta > 1 or delta > 1 or gamma > 5:
return -np.inf
if M1 < 11 or M1 > 13.2 or Ms0 < 10 or Ms0 > 12:
return -np.inf
else:
return -chi2_noksi(idx_z, M1, Ms0, beta, delta, gamma)/2
elif idx_z == 5 :
if beta < 0 or delta < 0 or gamma < 0:
return -np.inf
if beta > 1 or delta > 1 or gamma > 5:
return -np.inf
if M1 < 11.5 or M1 > 14 or Ms0 < 11 or Ms0 > 12:
return -np.inf
else:
return -chi2_noksi(idx_z, M1, Ms0, beta, delta, gamma)/2
elif idx_z == 6 :
if beta < 0 or delta < 0 or gamma < 0:
return -np.inf
if beta > 1 or delta > 1 or gamma > 5:
return -np.inf
if M1 < 12 or M1 > 15 or Ms0 < 10 or Ms0 > 13:
return -np.inf
else:
return -chi2_noksi(idx_z, M1, Ms0, beta, delta, gamma)/2
elif idx_z > 6 :
if beta < 0 or delta < 0 or gamma < 0:
return -np.inf
if beta > 1 or delta > 1 or gamma > 5:
return -np.inf
if M1 < 12 or M1 > 15 or Ms0 < 10 or Ms0 > 15:
return -np.inf
else:
return -chi2_noksi(idx_z, M1, Ms0, beta, delta, gamma)/2
def negloglike(theta, idx_z):
return -loglike(theta, idx_z)
def negloglike_noksi(theta, idx_z):
return -loglike_noksi(theta, idx_z)
"""Find maximum likelihood estimation"""
def maxlikelihood(idx_z, theta0, bounds):
load_smf()
load_hmf()
# idx_z = 0
# theta0 = np.array([11, 10, 0.1, 0.1, 1])
# bounds = ((11, 13), (10, 12), (0, 1), (0, 1), (0, 3), (0, 1))
# results = op.minimize(negloglike_noksi, theta0, bounds=bounds, args=(idx_z), method='TNC')
# results = op.basinhopping(negloglike, theta0, niter=1, T=1000, minimizer_kwargs={'args': idx_z})
# results = op.minimize(negloglike_noksi, theta0, args=(idx_z), method='Nelder-Mead', options={'fatol':10**-6})
results = op.minimize(negloglike, theta0, args=(idx_z), method='Nelder-Mead', options={'fatol':10**-6})
print(results)
"""Plots"""
def plotSMF_noksi(idx_z, iterations, burn):
load_smf()
load_hmf()
chain = np.load("../MCMC_Candels/Chain/Chain_noksi_z" + str(idx_z) + "_niter=" + str(iterations) + ".npy")
samples = chain[:, burn:, :].reshape((-1, chain.shape[2]))
select = np.where(np.logical_and(
smf_candels[idx_z][:, 1] > -10, # select points where the smf is defined
smf_candels[idx_z][:, 3] < 900))[0] # select points where the error bar is defined
logMs = smf_candels[idx_z][select, 0]
plt.figure()
plt.errorbar(logMs, smf_candels[idx_z][select, 1],
yerr=[smf_candels[idx_z][select, 1] - smf_candels[idx_z][select, 3],
smf_candels[idx_z][select, 2] - smf_candels[idx_z][select, 1]], fmt='o')
plt.ylim(-6, 0)
for M1, Ms0, beta, delta, gamma in samples[np.random.randint(len(samples), size=100)]:
logphi = log_phi_direct(logMs, idx_z, M1, Ms0, beta, delta, gamma)
plt.plot(logMs, logphi, color="k", alpha=0.1)
# plt.show()
plt.savefig('../MCMC_Candels/Plots/SMF_noksi'+ str(idx_z) + "_niter=" + str(iterations) + '.pdf')
def plotSMF(idx_z, iterations, burn):
load_smf()
load_hmf()
chain = np.load("../MCMC_Candels/Chain/Chain_ksi_z" + str(idx_z) + "_niter=" + str(iterations) + ".npy")
samples = chain[:, burn:, :].reshape((-1, chain.shape[2]))
select = np.where(smf_candels[idx_z][:, 1] > -1000)[0]
logMs = smf_candels[idx_z][select, 0]
plt.figure()
plt.errorbar(logMs, smf_candels[idx_z][select, 1],
yerr=[smf_candels[idx_z][select, 3], smf_candels[idx_z][select, 2]], fmt='o')
plt.ylim(-6, 0)
for M1, Ms0, beta, delta, gamma, ksi in samples[np.random.randint(len(samples), size=100)]:
logphi = log_phi_true(logMs, idx_z, M1, Ms0, beta, delta, gamma, ksi)
plt.plot(logMs, logphi, color="k", alpha=0.1)
# plt.show()
plt.savefig('../MCMC_Candels/Plots/SMF_ksi' + str(idx_z) + "_niter=" + str(iterations) + '.pdf')
def plotSMHM(idx_z, iterations, burn):
load_smf()
load_hmf()
chain = np.load("../MCMC_Candels/Chain/Chain_ksi_z" + str(idx_z) + "_niter=" + str(iterations) + ".npy")
samples = chain[:, burn:, :].reshape((-1, chain.shape[2]))
logMs = np.linspace(9, 11.5, num=200)
plt.figure()
for M1, Ms0, beta, delta, gamma, ksi in samples[np.random.randint(len(samples), size=100)]:
logmhalo = logMh(logMs, M1, Ms0, beta, delta, gamma)
plt.plot(logmhalo, logMs-logmhalo, color="k", alpha=0.1)
plt.show()
plt.savefig('../MCMC_Candels/Plots/SMHM_ksi' + str(idx_z) + "_niter=" + str(iterations) + '.pdf')
def plotSMHM_noksi(idx_z, iterations, burn):
load_smf()
load_hmf()
chain = np.load("../MCMC_Candels/Chain/Chain_noksi_z" + str(idx_z) + "_niter=" + str(iterations) + ".npy")
samples = chain[:, burn:, :].reshape((-1, chain.shape[2]))
logMs = np.linspace(9, 11.5, num=200)
plt.figure()
for M1, Ms0, beta, delta, gamma in samples[np.random.randint(len(samples), size=100)]:
logmhalo = logMh(logMs, M1, Ms0, beta, delta, gamma)
plt.plot(logmhalo, logMs-logmhalo, color="k", alpha=0.1)
# plt.show()
plt.savefig('../MCMC_Candels/Plots/SMHM_noksi'+ str(idx_z) + "_niter=" + str(iterations) + '.pdf')
def plotHMvsSM_noksi(idx_z, iterations, burn):
load_smf()
load_hmf()
plt.close('all')
chain = np.load("../MCMC_Candels/Chain/Chain_noksi_z" + str(idx_z) + "_niter=" + str(iterations) + ".npy")
samples = chain[:, burn:, :].reshape((-1, chain.shape[2]))
logMs = np.linspace(9, 11.5, num=200)
for M1, Ms0, beta, delta, gamma in samples[np.random.randint(len(samples), size=100)]:
logmhalo = logMh(logMs, M1, Ms0, beta, delta, gamma)
plt.plot(logMs, logmhalo, color="k", alpha=0.1)
plt.xlabel('log Ms')
plt.ylabel('log Mhalo')
# plt.show()
plt.savefig('../MCMC_Candels/Plots/HMvsSM_noksi'+ str(idx_z) + "_niter=" + str(iterations) + '.pdf')
def plotchain(chainfile, idx_z, iterations, burn):
chain = np.load(chainfile)
figname = "../MCMC_Candels/Plots/Ksi_z" + str(idx_z) + "_niter=" + str(iterations) + "_burn=" + str(burn)
samples = chain[:, burn:, :].reshape((-1, chain.shape[2]))
fig = corner.corner(
samples, labels=['$M_{1}$', '$M_{*,0}$', '$\\beta$', '$\delta$', '$\gamma$', 'ksi'])
fig.savefig(figname + ".pdf")
plt.close('all')
def plotchain_noksi(chainfile, idx_z, iterations, burn):
chain = np.load(chainfile)
figname = "../MCMC_Candels/Plots/Noksi_z" + str(idx_z) + "_niter=" + str(iterations) + "_burn=" + str(burn)
samples = chain[:, burn:, :].reshape((-1, chain.shape[2]))
fig = corner.corner(
samples, labels=['$M_{1}$', '$M_{*,0}$', '$\\beta$', '$\delta$', '$\gamma$'])
fig.savefig(figname + ".pdf")
plt.close('all')
# for (p, loglike, state) in sampler.sample(p0, iterations=iterations):
# print(p)
# print(loglike)
def plotdist(chainfile, idx_z, iterations, burn):
chain = np.load(chainfile)
figname = "../MCMC_Candels/Plots/Ksi_z" + str(idx_z) + "_niter=" + str(iterations) + "_burn=" + str(burn)
names = ['$M_{1}$', '$M_{s,0}$', '$\\beta$', '$\delta$', '$\gamma$', 'ksi']
samples = chain[:, burn:, :].reshape((-1, chain.shape[2]))
samples = MCSamples(samples = samples, names = names)
g = plots.getSubplotPlotter()
g.triangle_plot(samples, filled=True)
g.export(figname + '_gd.pdf' )
plt.clf()
def plotdist_noksi(chainfile, idx_z, iterations, burn):
chain = np.load(chainfile)
figname = "../MCMC_Candels/Plots/Noksi_z" + str(idx_z) + "_niter=" + str(iterations) + "_burn=" + str(burn)
names = ['$M_{1}$', '$M_{s,0}$', '$\\beta$', '$\delta$', '$\gamma$']
samples = chain[:, burn:, :].reshape((-1, chain.shape[2]))
samples = MCSamples(samples = samples, names = names)
g = plots.getSubplotPlotter()
g.triangle_plot(samples, filled=True)
g.export(figname + '_gd.pdf' )
plt.clf()
def plotLnprob():
for k in range(20):
plt.plot(lnprob[k, :])
def plot_Mhpeak(chainfile, idx_z, iterations, burn):
mhpeak = MhPeak(chainfile, idx_z, iterations, burn)
avg_mhpeak = np.mean(mhpeak)
std_mhpeak = np.std(mhpeak)
plt.figure()
plt.hist(mhpeak, bins=100)
plt.axvline(avg_mhpeak, color='orange')
plt.title('idx_z = ' + str(idx_z) +', MhPeak = ' + str(avg_mhpeak) + '+/-' + str(std_mhpeak))
plt.savefig('../MCMC_Candels/Plots/MhaloPeak/MhPeak_z' + str(idx_z) + '.pdf')
""" Run MCMC """
def runMCMC(idx_z, starting_point, std, iterations, burn, nthreads):
load_smf()
load_hmf()
start_time = time.time()
nwalker = 20
# nthreads = 16 # Put more for multiprocessing automatically.
# starting_point = np.array([12.5, 10.8, 0.5, 0.5, 0.5, 0.15])
# std =np.array([0.1, 0.1, 0.1, 0.1, 0.1, 0.01])
# starting_point = np.array([12.5, 11, 0.5, 0.7, 0.5, 0.15])
p0 = emcee.utils.sample_ball(starting_point, std, size=nwalker)
ndim = len(starting_point)
sampler = emcee.EnsembleSampler(nwalker, ndim, loglike, args=[idx_z], threads=nthreads)
print("ndim = " + str(ndim))
print("start = " + str(starting_point))
print("std = " + str(std))
print("iterations = " + str(iterations))
sampler.run_mcmc(p0, iterations)
chainfile = "../MCMC_Candels/Chain/Chain_ksi_z" + str(idx_z) + "_niter=" + str(iterations) + ".npy"
np.save(chainfile, sampler.chain)
print("--- %s seconds ---" % (time.time() - start_time))
plotchain(chainfile, idx_z, iterations, burn)
def runMCMC_noksi(idx_z, starting_point, std, iterations, burn, nthreads=1):
load_smf()
load_hmf()
nwalker = 20
# Put more nthreads for multiprocessing automatically.
# starting_point = np.array([12, 11, 0.5, 0.5, 2.5])
# std = np.array([1, 1, 0.1, 0.1, 0.1])
p0 = emcee.utils.sample_ball(starting_point, std, size=nwalker)
ndim = len(starting_point)
sampler = emcee.EnsembleSampler(nwalker, ndim, loglike_noksi, args=[idx_z], threads=nthreads)
print("idx_z = " +str (idx_z))
print("ndim = " + str(ndim))
print("start = " + str(starting_point))
print("std = " + str(std))
print("iterations = " + str(iterations))
start_time = time.time()
sampler.run_mcmc(p0, iterations)
## Monitor the sampling progress
# nsteps = iterations/100
# width = 30
# for i, result in enumerate(sampler.sample(p0, iterations=nsteps)):
# n = int((width+1) * float(i) / nsteps)
# sys.stdout.write("\r[{0}{1}]".format('#' * n, ' ' * (width - n)))
# sys.stdout.write("\n")
elapsed_time = time.time() - start_time
print('Time elapsed : ' + str(elapsed_time))
savename = "../MCMC_Candels/Chain/Chain_noksi_z" + str(idx_z) + "_niter=" + str(iterations) + ".npy"
savenameln = "../MCMC_Candels/Chain/LnProb_noksi_z" + str(idx_z) + "_niter=" + str(iterations) + ".npy"
np.save(savename, sampler.chain)
np.save(savenameln, sampler.lnprobability)
plotchain_noksi(savename, idx_z, iterations, burn)
plotSMF_noksi(idx_z, iterations, burn)
plotSMHM_noksi(idx_z, iterations, burn)
plot_Mhpeak(savename, idx_z, iterations, burn)
save_results(savename, idx_z, iterations, burn)
plotHMvsSM_noksi(idx_z, iterations, burn)
def save_results(chainfile, idx_z, iterations, burn):
chain = np.load(chainfile)
# names = ['$M_{1}$', '$M_{s,0}$', '$\\beta$', '$\delta$', '$\gamma$', 'ksi']
names = ['$M_{1}$', '$M_{s,0}$', '$\\beta$', '$\delta$', '$\gamma$']
samples = chain[:, burn:, :].reshape((-1, chain.shape[2]))
samples = MCSamples(samples = samples, names = names)
res = samples.getTable()
#res.write("../MCMC_Candels/Results/Chain_ksi_z" + str(idx_z) + "_niter=" + str(iterations) + ".txt")
res.write("../MCMC_Candels/Results/Chain_Noksi_z" + str(idx_z) + "_niter=" + str(iterations) + ".txt")
def MhPeak(chainfile, idx_z, iterations, burn):
chain = np.load(chainfile)
samples = chain[:, burn:, :].reshape((-1, chain.shape[2]))
chainsize = np.shape(samples)[0]
logMs = np.linspace(8, 12, num=300)
Mhalopeak = np.zeros(chainsize)
for i in range(chainsize):
logmhalo = logMh(logMs, samples[i, 0], samples[i, 1], samples[i, 2], samples[i, 3], samples[i, 4])
Mhalopeak_idx = np.argmax(logMs - logmhalo)
Mhalopeak[i]= logmhalo[Mhalopeak_idx]
return Mhalopeak
# f = open("chain.dat", "w")
# f.close()
# for result in sampler.sample(p0, iterations=iterations):
# position = result[0]
# f = open("chain.dat", "a")
# for k in range(position.shape[0]):
# f.write("{0:4d} {1:s}\n".format(k, " ".join(position[k])))
# f.close()
# if __name__ == "__main__":
# main()
"""Plots and tests"""
# logMs = np.linspace(6, 12, num=100)
# plt.plot(logMs, logMh(logMs, 13, 10, 0.5, 0.5, 2.5))
# logmhtest =logMh(logMs, 13, 14, 0.5, 0.5, 2.5)
# plt.plot(logMh(logMs, 12, 10, 0.5, 0.5, 2.5), logMs - logMh(logMs, 12, 10, 0.5, 0.5, 2.5))
# Compare Observed and predicted SMF :
# load_smf()
# load_hmf()
# select = np.where(smf_candels[idx_z][:, 1] > -1000)[0]
# logMs = smf_candels[idx_z][select, 0]
# plt.errorbar(logMs, smf_candels[idx_z][select, 1],
# yerr=[smf_candels[idx_z][select, 3], smf_candels[idx_z][select, 2]], fmt='o')
# plt.ylim(-6, 0)
# # logphi = log_phi_direct(logMs, idx_z, 12.2, 10.8, 0.3, 0, 0.3)
# """ Leauthaud fit parameters for idx_z=0, we note a small difference maybe coming form the HMF"""
# # logphi = log_phi_direct(logMs, idx_z, 12.52, 10.916, 0.457, 0.566, 1.53)
# # # logphi = log_phi_true(logMs, idx_z, 12.52, 10.916, 0.457, 0.566, 1.53, 0.206**2)
# # logphi = log_phi_direct(logMs, idx_z, 12.518, 10.917, 0.456, 0.582, 1.48)
# """ Leauthaud fit parametres for idx_z=1 """
# # logphi = log_phi_direct(logMs, idx_z, 12.725, 11.038, 0.466, 0.61, 1.95)
# logphi = log_phi_direct(logMs, idx_z, 12.725, 11.038, 0.466, 0.61, 0.7) # fits better with smaller gamma
# plt.plot(logMs, logphi)
# logphi = log_phi_true(logMs, idx_z, M1, Ms0, beta, delta, gamma, ksi)
# logmhalo = logMh(logMs, M1, Ms0, beta, delta, gamma)
# plt.plot(logMs, logmhalo)
"""Good fit by eye for the idx_z=1, no_ksi
starting_point = ([12.7, 11.1, 0.5, 0.3, 1.2])
"""
# chi2_noksi(0, 12.7, 8.9, 0.3, 0.6, 2.5)
# theta = np.array([12.7, 8.9, 0.3, 0.6, 2.5])
# theta = np.array([ 11.73672883, 10.63457168 , 0.55492575 , 0.45137568 , 2.58689832])
# plt.plot(hmf_bolshoi[0][:,0], hmf_bolshoi[0][:,2])
# thetavar = np.array([np.linspace(10, 14, num=100), np.full(100, 11), np.full(100,0.5),
# np.full(100,0.5), np.full(100,2.5), np.full(100,0.15)])
# neglog = np.zeros(100)
# idx_z = 0
# for i in range(100):
# neglog[i] = negloglike(thetavar[:,i], idx_z)
# plt.plot(neglog)
# for i in range(ndim):
# plt.figure()
# for j in range(nwalker):
# plt.plot(chain[j, :, i], '.')
# plt.show()
# """Test emcee sampling"""
# nwalker=250
# ndim=6
# std = np.array([1, 1, 0.1, 0.1, 0.1, 0.1])
# p0 = emcee.utils.sample_ball(theta0, std, size=nwalker)
# sampler= emcee.EnsembleSampler(nwalker, ndim, negloglike, args=[idx_z])
# pos, prob, state = sampler.run_mcmc(p0, 100) ## burn phase
# sampler.run_mcmc(pos, 1000) ## samble phase
"""Select the chains that converged"""
# chain = np.load("../MCMC_Candels/Chain/Chain_noksi_z" + str(idx_z) + "_niter=" + str(iterations) + ".npy")
# lnprob = np.load("../MCMC_Candels/Chain/LnProb_noksi_z" + str(idx_z) + "_niter=" + str(iterations) + ".npy")
# for k in range(20):
# plt.plot(lnprob[k, :])
# select = np.where(lnprob[:, -1]>-30)
# chain = chain[lnprob[:, -1]>-30, :, :] | gpl-3.0 |
TMiguelT/PandasSchema | pandas_schema/column.py | 1 | 1246 | import typing
import pandas as pd
from . import validation
from .validation_warning import ValidationWarning
class Column:
def __init__(self, name: str, validations: typing.Iterable['validation._BaseValidation'] = [], allow_empty=False):
"""
Creates a new Column object
:param name: The column header that defines this column. This must be identical to the header used in the CSV/Data Frame you are validating.
:param validations: An iterable of objects implementing _BaseValidation that will generate ValidationErrors
:param allow_empty: True if an empty column is considered valid. False if we leave that logic up to the Validation
"""
self.name = name
self.validations = list(validations)
self.allow_empty = allow_empty
def validate(self, series: pd.Series) -> typing.List[ValidationWarning]:
"""
Creates a list of validation errors using the Validation objects contained in the Column
:param series: A pandas Series to validate
:return: An iterable of ValidationError instances generated by the validation
"""
return [error for validation in self.validations for error in validation.get_errors(series, self)]
| gpl-3.0 |
dimkal/mne-python | mne/decoding/ems.py | 16 | 4347 | # Author: Denis Engemann <[email protected]>
# Alexandre Gramfort <[email protected]>
#
# License: BSD (3-clause)
import numpy as np
from ..utils import logger, verbose
from ..fixes import Counter
from ..parallel import parallel_func
from .. import pick_types, pick_info
@verbose
def compute_ems(epochs, conditions=None, picks=None, n_jobs=1, verbose=None):
"""Compute event-matched spatial filter on epochs
This version operates on the entire time course. No time window needs to
be specified. The result is a spatial filter at each time point and a
corresponding time course. Intuitively, the result gives the similarity
between the filter at each time point and the data vector (sensors) at
that time point.
References
----------
[1] Aaron Schurger, Sebastien Marti, and Stanislas Dehaene, "Reducing
multi-sensor data to a single time course that reveals experimental
effects", BMC Neuroscience 2013, 14:122
Parameters
----------
epochs : instance of mne.Epochs
The epochs.
conditions : list of str | None
If a list of strings, strings must match the
epochs.event_id's key as well as the number of conditions supported
by the objective_function. If None keys in epochs.event_id are used.
picks : array-like of int | None
Channels to be included. If None only good data channels are used.
Defaults to None
n_jobs : int
Number of jobs to run in parallel.
verbose : bool, str, int, or None
If not None, override default verbose level (see mne.verbose).
Defaults to self.verbose.
Returns
-------
surrogate_trials : ndarray, shape (trials, n_trials, n_time_points)
The trial surrogates.
mean_spatial_filter : ndarray, shape (n_channels, n_times)
The set of spatial filters.
conditions : ndarray, shape (n_epochs,)
The conditions used. Values correspond to original event ids.
"""
logger.info('...computing surrogate time series. This can take some time')
if picks is None:
picks = pick_types(epochs.info, meg=True, eeg=True)
if not len(set(Counter(epochs.events[:, 2]).values())) == 1:
raise ValueError('The same number of epochs is required by '
'this function. Please consider '
'`epochs.equalize_event_counts`')
if conditions is None:
conditions = epochs.event_id.keys()
epochs = epochs.copy()
else:
epochs = epochs[conditions]
epochs.drop_bad_epochs()
if len(conditions) != 2:
raise ValueError('Currently this function expects exactly 2 '
'conditions but you gave me %i' %
len(conditions))
ev = epochs.events[:, 2]
# special care to avoid path dependant mappings and orders
conditions = list(sorted(conditions))
cond_idx = [np.where(ev == epochs.event_id[k])[0] for k in conditions]
info = pick_info(epochs.info, picks)
data = epochs.get_data()[:, picks]
# Scale (z-score) the data by channel type
for ch_type in ['mag', 'grad', 'eeg']:
if ch_type in epochs:
if ch_type == 'eeg':
this_picks = pick_types(info, meg=False, eeg=True)
else:
this_picks = pick_types(info, meg=ch_type, eeg=False)
data[:, this_picks] /= np.std(data[:, this_picks])
from sklearn.cross_validation import LeaveOneOut
parallel, p_func, _ = parallel_func(_run_ems, n_jobs=n_jobs)
out = parallel(p_func(_ems_diff, data, cond_idx, train, test)
for train, test in LeaveOneOut(len(data)))
surrogate_trials, spatial_filter = zip(*out)
surrogate_trials = np.array(surrogate_trials)
spatial_filter = np.mean(spatial_filter, axis=0)
return surrogate_trials, spatial_filter, epochs.events[:, 2]
def _ems_diff(data0, data1):
"""default diff objective function"""
return np.mean(data0, axis=0) - np.mean(data1, axis=0)
def _run_ems(objective_function, data, cond_idx, train, test):
d = objective_function(*(data[np.intersect1d(c, train)] for c in cond_idx))
d /= np.sqrt(np.sum(d ** 2, axis=0))[None, :]
# compute surrogates
return np.sum(data[test[0]] * d, axis=0), d
| bsd-3-clause |
gyglim/Recipes | papers/preactivation_and_wide_resnet/train_nn.py | 3 | 5152 | """
Lasagne implementation of CIFAR-10 examples from "Identity Mappings in Deep Residual Networks" (https://arxiv.org/abs/1603.05027) and "Wide Residual Networks" (https://arxiv.org/abs/1605.07146)
"""
import sys
import gzip
import time
import pickle
import numpy as np
import theano
from theano import tensor as T
import lasagne
from lasagne.updates import nesterov_momentum, adam
from lasagne.layers import helper
from utils import load_pickle_data_cv, batch_iterator_valid, batch_iterator_train_crop_flip
from matplotlib import pyplot
variant = sys.argv[1] if len(sys.argv) > 1 else 'normal'
depth = int(sys.argv[2]) if len(sys.argv) > 2 else 18
width = int(sys.argv[3]) if len(sys.argv) > 3 else 1
print 'Using %s ResNet with depth %d and width %d.'%(variant,depth,width)
if variant == 'normal':
from models import ResNet_FullPreActivation as ResNet
elif variant == 'bottleneck':
from models import ResNet_BottleNeck_FullPreActivation as ResNet
elif variant == 'wide':
from models import ResNet_FullPre_Wide as ResNet
else:
print 'Unsupported model %s'%variant
# training params
ITERS = 200
BATCHSIZE = 64
LR_SCHEDULE = {
0: 0.01,
10: 0.1,
80: 0.01,
120: 0.001,
}
"""
Set up all theano functions
"""
X = T.tensor4('X')
Y = T.ivector('y')
# set up theano functions to generate output by feeding data through network, any test outputs should be deterministic
# load model
if width > 1:
output_layer = ResNet(X, n=depth, k=width)
else:
output_layer = ResNet(X, n=depth)
# create outputs
output_train = lasagne.layers.get_output(output_layer)
output_test = lasagne.layers.get_output(output_layer, deterministic=True)
# set up the loss that we aim to minimize when using cat cross entropy our Y should be ints not one-hot
loss = lasagne.objectives.categorical_crossentropy(output_train, Y)
loss = loss.mean()
# if using ResNet use L2 regularization
all_layers = lasagne.layers.get_all_layers(output_layer)
l2_penalty = lasagne.regularization.regularize_layer_params(all_layers, lasagne.regularization.l2) * 0.0001
loss = loss + l2_penalty
# set up loss functions for validation dataset
test_loss = lasagne.objectives.categorical_crossentropy(output_test, Y)
test_loss = test_loss.mean()
test_acc = T.mean(T.eq(T.argmax(output_test, axis=1), Y), dtype=theano.config.floatX)
# get parameters from network and set up sgd with nesterov momentum to update parameters, l_r is shared var so it can be changed
l_r = theano.shared(np.array(LR_SCHEDULE[0], dtype=theano.config.floatX))
params = lasagne.layers.get_all_params(output_layer, trainable=True)
updates = nesterov_momentum(loss, params, learning_rate=l_r, momentum=0.9)
#updates = adam(loss, params, learning_rate=l_r)
# set up training and prediction functions
train_fn = theano.function(inputs=[X,Y], outputs=loss, updates=updates)
valid_fn = theano.function(inputs=[X,Y], outputs=[test_loss, test_acc])
'''
load training data and start training
'''
# load the training and validation data sets
train_X, test_X, train_y, test_y = load_pickle_data_cv()
print 'Train shape:', train_X.shape, 'Test shape:', test_X.shape
print 'Train y shape:', train_y.shape, 'Test y shape:', test_y.shape
print np.amax(train_X), np.amin(train_X), np.mean(train_X)
# loop over training functions for however many iterations, print information while training
train_eval = []
valid_eval = []
valid_acc = []
best_acc = 0.0
try:
for epoch in range(ITERS):
# change learning rate according to schedules
if epoch in LR_SCHEDULE:
l_r.set_value(LR_SCHEDULE[epoch])
# do the training
start = time.time()
train_loss = batch_iterator_train_crop_flip(train_X, train_y, BATCHSIZE, train_fn)
train_eval.append(train_loss)
valid_loss, acc_v = batch_iterator_valid(test_X, test_y, BATCHSIZE, valid_fn)
valid_eval.append(valid_loss)
valid_acc.append(1.0 - acc_v)
ratio = train_loss / valid_loss
end = time.time() - start
# print training details
print 'iter:', epoch, '| TL:', np.round(train_loss,decimals=3), '| VL:', np.round(valid_loss,decimals=3), '| Vacc:', np.round(acc_v,decimals=3), '| Ratio:', np.round(ratio,decimals=2), '| Time:', np.round(end,decimals=1)
if acc_v > best_acc:
best_acc = acc_v
best_params = helper.get_all_param_values(output_layer)
except KeyboardInterrupt:
pass
print "Final Acc:", best_acc
# save weights
all_params = helper.get_all_param_values(output_layer)
f = gzip.open('data/weights/%s%d_resnet.pklz'%(variant,depth), 'wb')
pickle.dump(best_params, f)
f.close()
# plot loss and accuracy
train_eval = np.array(train_eval)
valid_acc = np.array(valid_acc)
pyplot.plot(train_eval, label='Train loss', color='#707070')
pyplot.ylabel('Categorical Cross Entropy Loss')
pyplot.xlabel('Epoch')
pyplot.legend(loc=2)
#pyplot.ylim([0,1.5])
pyplot.twinx()
pyplot.ylabel('Valid Acc Error (%)')
pyplot.grid()
pyplot.plot(valid_acc, label='Valid classification error (%)', color='#ED5724')
pyplot.legend(loc=1)
pyplot.savefig('plots/%s%d_resnet.png'%(variant,depth))
pyplot.clf()
#pyplot.show()
| mit |
kadubarbosa/aga503 | ep4.py | 1 | 2764 | # -*- coding: utf-8 -*-
"""
Created on 05/11/15
@author: Carlos Eduardo Barbosa
Resposta do exercicio 4
"""
import os
import numpy as np
from scipy.optimize import leastsq
import matplotlib.pyplot as plt
def planck(wave, temp):
""" Returns the Planck's Law intensities.
Wavelengths are in Angstroms
Temperatures in K.
Output is converted to ergs/cm2/s/A to reproduce IDL version."""
k = 1.380658e-16 # Boltzmann constant in erg / K
h = 6.6260755e-27 # Planck constant in erg / s
c = 2.99792458e10 # Speed of light in cm / s
w = wave * 1.e-8 # Convertion to cm
B = 2 * h * c * c * np.power(w, -5) / (np.exp(h * c / (w * k * temp)) - 1.)
# Returns Planck's Law in units of ergs/cm2/s/A
return np.pi * B * 1e-8
def model(wave, T1, T2):
return planck(wave, T1) / (sigma * T1 * T1 * T1 * T1) + \
planck(wave, T2) / (sigma * T2 * T2 * T2 * T2)
def chi2(wave, flux, err, T1, T2):
""" Return the Chi2 map. """
chi2map = np.zeros_like(T1)
for w,f,e in zip(wave,flux,err):
chi2map += np.power((f - model(w, T1, T2)) / e, 2.)
return chi2map / (len(wave) - 1)
if __name__ == "__main__":
## Physical constants ####################################################
k = 1.380658e-16 # Boltzmann constant in erg / K
h = 6.6260755e-27 # Planck constant in erg / s
c = 2.99792458e10 # Speed of light in cm / s
sigma = 5.670367e-5 # Stefan-Boltzman constant in erg / cm2 / s / K4
##########################################################################
table = "/home/kadu/Dropbox/aga503/ep4/dados_vinicius.txt"
wave, flux, err = np.loadtxt(table).T
##########################################################################
# fig1 = plt.figure(1)
# ax1 = plt.subplot(211)
# ax1.errorbar(wave, flux, yerr=err)
# ax1.minorticks_on()
# plt.pause(0.001)
##########################################################################
t1 = np.linspace(3000, 6000., 100)
t2 = np.linspace(700, 1000., 100)
# t1 = np.linspace(5100, 5150., 100)
# t2 = np.linspace(100, 1000., 100)
T1, T2 = np.meshgrid(t1,t2)
# fig3 = plt.figure(3)
# plt.imshow(np.sqrt(T1**2 + T2**2), origin="bottom")
# plt.colorbar()
fig2 = plt.figure(2)
plt.minorticks_on()
map = chi2(wave, flux, err, T1, T2)
print map.min(), map.max()
# map = np.clip(map, map.min(), 10* map.min())
idx =np.where(map == map.min())[0]
plt.imshow(map, origin="bottom", extent=[t1[0], t1[-1], t2[0], t2[-1]],
aspect="auto", vmin=1, vmax=5)
plt.xlabel(r"$T_1$ [K]")
plt.ylabel(r"$T_2$ [K]")
plt.colorbar(label=r"$\chi^2_\nu$")
plt.tight_layout()
plt.savefig("chi2.png")
plt.show(block=1)
| gpl-2.0 |
davisvideochallenge/davis2017-evaluation | davis2017/davis.py | 1 | 5514 | import os
from glob import glob
from collections import defaultdict
import numpy as np
from PIL import Image
class DAVIS(object):
SUBSET_OPTIONS = ['train', 'val', 'test-dev', 'test-challenge']
TASKS = ['semi-supervised', 'unsupervised']
DATASET_WEB = 'https://davischallenge.org/davis2017/code.html'
VOID_LABEL = 255
def __init__(self, root, task='unsupervised', subset='val', sequences='all', resolution='480p', codalab=False):
"""
Class to read the DAVIS dataset
:param root: Path to the DAVIS folder that contains JPEGImages, Annotations, etc. folders.
:param task: Task to load the annotations, choose between semi-supervised or unsupervised.
:param subset: Set to load the annotations
:param sequences: Sequences to consider, 'all' to use all the sequences in a set.
:param resolution: Specify the resolution to use the dataset, choose between '480' and 'Full-Resolution'
"""
if subset not in self.SUBSET_OPTIONS:
raise ValueError(f'Subset should be in {self.SUBSET_OPTIONS}')
if task not in self.TASKS:
raise ValueError(f'The only tasks that are supported are {self.TASKS}')
self.task = task
self.subset = subset
self.root = root
self.img_path = os.path.join(self.root, 'JPEGImages', resolution)
annotations_folder = 'Annotations' if task == 'semi-supervised' else 'Annotations_unsupervised'
self.mask_path = os.path.join(self.root, annotations_folder, resolution)
year = '2019' if task == 'unsupervised' and (subset == 'test-dev' or subset == 'test-challenge') else '2017'
self.imagesets_path = os.path.join(self.root, 'ImageSets', year)
self._check_directories()
if sequences == 'all':
with open(os.path.join(self.imagesets_path, f'{self.subset}.txt'), 'r') as f:
tmp = f.readlines()
sequences_names = [x.strip() for x in tmp]
else:
sequences_names = sequences if isinstance(sequences, list) else [sequences]
self.sequences = defaultdict(dict)
for seq in sequences_names:
images = np.sort(glob(os.path.join(self.img_path, seq, '*.jpg'))).tolist()
if len(images) == 0 and not codalab:
raise FileNotFoundError(f'Images for sequence {seq} not found.')
self.sequences[seq]['images'] = images
masks = np.sort(glob(os.path.join(self.mask_path, seq, '*.png'))).tolist()
masks.extend([-1] * (len(images) - len(masks)))
self.sequences[seq]['masks'] = masks
def _check_directories(self):
if not os.path.exists(self.root):
raise FileNotFoundError(f'DAVIS not found in the specified directory, download it from {self.DATASET_WEB}')
if not os.path.exists(os.path.join(self.imagesets_path, f'{self.subset}.txt')):
raise FileNotFoundError(f'Subset sequences list for {self.subset} not found, download the missing subset '
f'for the {self.task} task from {self.DATASET_WEB}')
if self.subset in ['train', 'val'] and not os.path.exists(self.mask_path):
raise FileNotFoundError(f'Annotations folder for the {self.task} task not found, download it from {self.DATASET_WEB}')
def get_frames(self, sequence):
for img, msk in zip(self.sequences[sequence]['images'], self.sequences[sequence]['masks']):
image = np.array(Image.open(img))
mask = None if msk is None else np.array(Image.open(msk))
yield image, mask
def _get_all_elements(self, sequence, obj_type):
obj = np.array(Image.open(self.sequences[sequence][obj_type][0]))
all_objs = np.zeros((len(self.sequences[sequence][obj_type]), *obj.shape))
obj_id = []
for i, obj in enumerate(self.sequences[sequence][obj_type]):
all_objs[i, ...] = np.array(Image.open(obj))
obj_id.append(''.join(obj.split('/')[-1].split('.')[:-1]))
return all_objs, obj_id
def get_all_images(self, sequence):
return self._get_all_elements(sequence, 'images')
def get_all_masks(self, sequence, separate_objects_masks=False):
masks, masks_id = self._get_all_elements(sequence, 'masks')
masks_void = np.zeros_like(masks)
# Separate void and object masks
for i in range(masks.shape[0]):
masks_void[i, ...] = masks[i, ...] == 255
masks[i, masks[i, ...] == 255] = 0
if separate_objects_masks:
num_objects = int(np.max(masks[0, ...]))
tmp = np.ones((num_objects, *masks.shape))
tmp = tmp * np.arange(1, num_objects + 1)[:, None, None, None]
masks = (tmp == masks[None, ...])
masks = masks > 0
return masks, masks_void, masks_id
def get_sequences(self):
for seq in self.sequences:
yield seq
if __name__ == '__main__':
from matplotlib import pyplot as plt
only_first_frame = True
subsets = ['train', 'val']
for s in subsets:
dataset = DAVIS(root='/home/csergi/scratch2/Databases/DAVIS2017_private', subset=s)
for seq in dataset.get_sequences():
g = dataset.get_frames(seq)
img, mask = next(g)
plt.subplot(2, 1, 1)
plt.title(seq)
plt.imshow(img)
plt.subplot(2, 1, 2)
plt.imshow(mask)
plt.show(block=True)
| bsd-3-clause |
effigies/PySurfer | setup.py | 4 | 3134 | #! /usr/bin/env python
#
# Copyright (C) 2011-2014 Alexandre Gramfort
# Michael Waskom
# Scott Burns
# Martin Luessi
# Eric Larson
descr = """PySurfer: cortical surface visualization using Python."""
import os
# deal with MPL sandbox violations during easy_install
os.environ['MPLCONFIGDIR'] = '.'
# get the version, don't import surfer here so setup works on headless systems
version = None
with open(os.path.join('surfer', '__init__.py'), 'r') as fid:
for line in (line.strip() for line in fid):
if line.startswith('__version__'):
version = line.split('=')[1].strip().strip('"')
break
if version is None:
raise RuntimeError('Could not determine version')
DISTNAME = 'pysurfer'
DESCRIPTION = descr
LONG_DESCRIPTION = descr
MAINTAINER = 'Michael Waskom'
MAINTAINER_EMAIL = '[email protected]'
URL = 'http://pysurfer.github.com'
LICENSE = 'BSD (3-clause)'
DOWNLOAD_URL = 'https://github.com/nipy/PySurfer'
VERSION = version
def check_dependencies():
needed_deps = ["IPython",
"numpy", "scipy", "matplotlib",
"mayavi",
]
missing_deps = []
for dep in needed_deps:
try:
__import__(dep)
except ImportError:
missing_deps.append(dep)
if missing_deps:
missing = ", ".join(missing_deps)
raise ImportError("Missing dependencies: %s" % missing)
from setuptools import setup
if __name__ == "__main__":
if os.path.exists('MANIFEST'):
os.remove('MANIFEST')
import sys
if not (len(sys.argv) >= 2 and ('--help' in sys.argv[1:] or
sys.argv[1] in ('--help-commands',
'--version',
'egg_info',
'clean'))):
check_dependencies()
setup(name=DISTNAME,
maintainer=MAINTAINER,
include_package_data=True,
maintainer_email=MAINTAINER_EMAIL,
description=DESCRIPTION,
license=LICENSE,
url=URL,
version=VERSION,
download_url=DOWNLOAD_URL,
long_description=LONG_DESCRIPTION,
zip_safe=False, # the package can run out of an .egg file
classifiers=['Intended Audience :: Science/Research',
'Intended Audience :: Developers',
'Programming Language :: Python :: 2.7',
'License :: OSI Approved',
'Programming Language :: Python',
'Topic :: Software Development',
'Topic :: Scientific/Engineering',
'Operating System :: Microsoft :: Windows',
'Operating System :: POSIX',
'Operating System :: Unix',
'Operating System :: MacOS'
],
platforms='any',
packages=['surfer', 'surfer.tests'],
scripts=['bin/pysurfer'],
install_requires=['nibabel >= 1.2'],
)
| bsd-3-clause |
othercriteria/StochasticBlockmodel | test_c_elegans.py | 1 | 9744 | #!/usr/bin/env python
# Application of network inference to C. elegans connectome
# Daniel Klein, 4/10/2013
import json
import numpy as np
import matplotlib.pyplot as plt
import networkx as nx
import xlrd
from Network import network_from_edges
from Models import StationaryLogistic, NonstationaryLogistic
from Models import FixedMargins, alpha_zero
# Parameters
params = { 'use_gap': False,
'use_chemical': True,
'cov_gap': False,
'cov_chemical': False,
'cov_soma_diff': False,
'cov_soma_dist': True,
'cov_soma_dir': False,
'cov_lineage': False,
'cov_class': False,
'file_network': 'data/c_elegans_chen/NeuronConnect.xls',
'file_neurons': 'data/c_elegans_chen/NeuronType.xls',
'file_landmarks': 'data/c_elegans_chen/NeuronFixedPoints.xls',
'file_lineage_1': 'data/c_elegans_chen/NeuronLineage_Part1.xls',
'file_lineage_2': 'data/c_elegans_chen/NeuronLineage_Part2.xls',
'n_samples': 100,
'n_bootstrap': 100,
'outfile': 'out.pdf' }
# Import network connectivity from file
edges = []
edges_gap = set()
edges_chemical = set()
nodes = set()
wb_network = xlrd.open_workbook(params['file_network'])
ws_network = wb_network.sheet_by_name('NeuronConnect.csv')
for row in range(1, ws_network.nrows):
n_1 = ws_network.cell_value(row, 0)
n_2 = ws_network.cell_value(row, 1)
t = ws_network.cell_value(row, 2)[0]
if n_1 == 'NMJ' or n_2 == 'NMJ': continue
if t == 'E':
edges_gap.add((n_1, n_2))
edges_gap.add((n_2, n_1))
if params['use_gap']:
edges.append((n_1, n_2))
edges.append((n_2, n_1))
nodes.add(n_1)
nodes.add(n_2)
if t == 'S':
edges_chemical.add((n_1, n_2))
if params['use_chemical']:
edges.append((n_1, n_2))
nodes.add(n_1)
nodes.add(n_2)
print '# Nodes: %d' % len(nodes)
# Initialize network from connectivity data
net = network_from_edges(edges)
net.initialize_offset()
for i in range(net.N):
net.offset[i,i] = -10.0
A = net.as_dense()
r = A.sum(1)
c = A.sum(0)
print '# Edges: %d' % A.sum()
cov_names = []
def add_cov_f(name, f):
cov_names.append(name)
net.new_edge_covariate(name).from_binary_function_name(f)
# Covariates from other synapse type
if params['cov_gap']:
def f_gap(n_1, n_2):
return (n_1, n_2) in edges_gap
add_cov_f('gap', f_gap)
if params['cov_chemical']:
def f_chemical(n_1, n_2):
return (n_1, n_2) in edges_chemical
add_cov_f('chemical', f_chemical)
# Import soma position from file
soma_pos = {}
wb_neurons = xlrd.open_workbook(params['file_neurons'])
ws_neurons = wb_neurons.sheet_by_name('NeuronType.csv')
for row in range(1, ws_neurons.nrows):
n = ws_neurons.cell_value(row, 0)
pos = ws_neurons.cell_value(row, 1)
soma_pos[n] = pos
cov = net.new_node_covariate('soma_pos')
cov.from_pairs(soma_pos.keys(), soma_pos.values())
if params['cov_soma_diff']:
def f_soma_pos_diff(n_1, n_2):
return (soma_pos[n_1] - soma_pos[n_2])
add_cov_f('soma_dist', f_soma_pos_diff)
if params['cov_soma_dist']:
def f_soma_pos_dist(n_1, n_2):
return abs(soma_pos[n_1] - soma_pos[n_2])
add_cov_f('soma_dist', f_soma_pos_dist)
if params['cov_soma_dir']:
def f_soma_pos_dir(n_1, n_2):
return soma_pos[n_2] > soma_pos[n_1]
add_cov_f('soma_dir', f_soma_pos_dir)
# Import landmark type (hence sensory, motor, inter-) from file
neuron_class = {}
wb_landmarks = xlrd.open_workbook(params['file_landmarks'])
ws_landmarks = wb_landmarks.sheet_by_name('NeuronFixedPoints.csv')
for row in range(1, ws_landmarks.nrows):
n = ws_landmarks.cell_value(row, 0)
t = ws_landmarks.cell_value(row, 1)[0]
neuron_class[n] = t
for n in net.names:
if not n in neuron_class:
neuron_class[n] = 'I'
if params['cov_class']:
for class_1 in ['S', 'I', 'M']:
for class_2 in ['S', 'I', 'M']:
if class_1 == 'I' and class_2 == 'I': continue
def f_same_class(n_1, n_2):
return ((neuron_class[n_1] == class_1) and
(neuron_class[n_2] == class_2))
add_cov_f('%s_%s' % (class_1, class_2), f_same_class)
# Import lineage distance from files
dist = {}
wb_lineage_1 = xlrd.open_workbook(params['file_lineage_1'])
ws_lineage_1 = wb_lineage_1.sheet_by_name('NeuronLineage_Part1.csv')
for row in range(1, ws_lineage_1.nrows):
n_1 = ws_lineage_1.cell_value(row, 0)
n_2 = ws_lineage_1.cell_value(row, 1)
d = ws_lineage_1.cell_value(row, 2)
dist[(n_1,n_2)] = d
dist[(n_2,n_1)] = d
wb_lineage_2 = xlrd.open_workbook(params['file_lineage_2'])
ws_lineage_2 = wb_lineage_2.sheet_by_name('NeuronLineage_Part2.csv')
for row in range(1, ws_lineage_1.nrows):
n_1 = ws_lineage_2.cell_value(row, 0)
n_2 = ws_lineage_2.cell_value(row, 1)
d = ws_lineage_2.cell_value(row, 2)
dist[(n_1,n_2)] = d
dist[(n_2,n_1)] = d
if params['cov_lineage']:
def f_lineage_dist(n_1, n_2):
if n_1 == n_2: return 0
return dist[(n_1, n_2)]
add_cov_f('lineage_dist', f_lineage_dist)
# Functions for plotting
def style(ax):
ax.tick_params(axis = 'both', which = 'both',
bottom = 'off', top = 'off', labelbottom = 'off',
left = 'off', right = 'off', labelleft = 'off')
def heatmap(ax, data):
ax.imshow(data[o][:,o]).set_cmap('binary')
style(ax)
def residuals(ax, data_mean, data_sd):
resid = np.abs((data_mean - A) / data_sd)
resid[(data_sd == 0) * (data_mean == A)] = 0.0
resid[(data_sd == 0) * (data_mean != A)] = 10.0
ax.imshow(resid[o][:,o], vmin = 0, vmax = 3.0).set_cmap('gray')
style(ax)
# Display observed network
o = np.argsort(net.node_covariates['soma_pos'][:])
A = net.as_dense()
fig, ax = plt.subplots()
ax.set_title('Observed connectome')
heatmap(ax, A)
plt.show()
fig, ax = plt.subplots()
ax.set_title('Observed connectome network')
graph = nx.DiGraph()
for n1, n2 in edges:
graph.add_edge(n1, n2)
pos = nx.nx_pydot.graphviz_layout(graph, prog = 'fdp')
nx.draw(graph, pos, ax = ax, node_size = 50, with_labels = False)
plt.show()
# Store sampled typical networks from fit models
s_samples = np.empty((params['n_samples'], net.N, net.N))
ns_samples = np.empty((params['n_samples'], net.N, net.N))
c_samples = np.empty((params['n_samples'], net.N, net.N))
def display_cis(model):
procedures = set()
for par in model.conf:
for procedure in model.conf[par]:
procedures.add(procedure)
for procedure in procedures:
print '%s:' % procedure
for par in model.conf:
if not procedure in model.conf[par]: continue
ci = model.conf[par][procedure]
print ' %s: (%.2f, %.2f)' % (par, ci[0], ci[1])
print
print 'Fitting stationary model'
s_model = StationaryLogistic()
for cov_name in cov_names:
s_model.beta[cov_name] = None
s_model.fit(net)
print 'NLL: %.2f' % s_model.nll(net)
print 'kappa: %.2f' % s_model.kappa
for cov_name in cov_names:
print '%s: %.2f' % (cov_name, s_model.beta[cov_name])
print
for rep in range(params['n_samples']):
s_samples[rep,:,:] = s_model.generate(net)
s_model.confidence_boot(net, n_bootstrap = params['n_bootstrap'])
s_model.confidence_wald(net)
display_cis(s_model)
print 'Fitting conditional model'
c_model = FixedMargins(StationaryLogistic())
net.new_row_covariate('r', np.int)[:] = r
net.new_col_covariate('c', np.int)[:] = c
c_model.fit = c_model.base_model.fit_conditional
for cov_name in cov_names:
c_model.base_model.beta[cov_name] = None
c_model.fit(net, verbose = True)
print 'NLL: %.2f' % c_model.nll(net)
for cov_name in cov_names:
print '%s: %.2f' % (cov_name, c_model.base_model.beta[cov_name])
print
for rep in range(params['n_samples']):
c_samples[rep,:,:] = c_model.generate(net, coverage = 0.1)
c_model.confidence_boot(net, n_bootstrap = params['n_bootstrap'])
c_model.confidence_wald(net)
for cov_name in cov_names:
c_model.confidence_cons(net, cov_name, L = 121, test = 'score')
c_model.confidence_cons(net, cov_name, L = 121, test = 'lr')
display_cis(c_model)
# Offset extreme substructure only for Nonstationary model
net.offset_extremes()
print 'Fitting nonstationary model'
ns_model = NonstationaryLogistic()
for cov_name in cov_names:
ns_model.beta[cov_name] = None
ns_model.fit(net)
print 'NLL: %.2f' % ns_model.nll(net)
print 'kappa: %.2f' % ns_model.kappa
for cov_name in cov_names:
print '%s: %.2f' % (cov_name, ns_model.beta[cov_name])
print
for rep in range(params['n_samples']):
ns_samples[rep,:,:] = ns_model.generate(net)
ns_model.confidence_boot(net, n_bootstrap = params['n_bootstrap'])
ns_model.confidence_wald(net)
display_cis(ns_model)
# Calculate sample means and variances
s_samples_mean = np.mean(s_samples, axis = 0)
s_samples_sd = np.sqrt(np.var(s_samples, axis = 0))
ns_samples_mean = np.mean(ns_samples, axis = 0)
ns_samples_sd = np.sqrt(np.var(ns_samples, axis = 0))
c_samples_mean = np.mean(c_samples, axis = 0)
c_samples_sd = np.sqrt(np.var(c_samples, axis = 0))
# Finish plotting
plt.figure()
ax = plt.subplot(231)
ax.set_title('Stationary')
heatmap(ax, s_samples_mean)
ax = plt.subplot(234)
residuals(ax, s_samples_mean, s_samples_sd)
ax = plt.subplot(232)
ax.set_title('Nonstationary')
heatmap(ax, ns_samples_mean)
ax = plt.subplot(235)
residuals(ax, ns_samples_mean, ns_samples_sd)
ax = plt.subplot(233)
ax.set_title('Conditional')
heatmap(ax, c_samples_mean)
ax = plt.subplot(236)
residuals(ax, c_samples_mean, c_samples_sd)
plt.tight_layout()
if params['outfile']:
plt.savefig(params['outfile'])
plt.show()
| mit |
MohammedWasim/scikit-learn | examples/plot_multilabel.py | 236 | 4157 | # Authors: Vlad Niculae, Mathieu Blondel
# License: BSD 3 clause
"""
=========================
Multilabel classification
=========================
This example simulates a multi-label document classification problem. The
dataset is generated randomly based on the following process:
- pick the number of labels: n ~ Poisson(n_labels)
- n times, choose a class c: c ~ Multinomial(theta)
- pick the document length: k ~ Poisson(length)
- k times, choose a word: w ~ Multinomial(theta_c)
In the above process, rejection sampling is used to make sure that n is more
than 2, and that the document length is never zero. Likewise, we reject classes
which have already been chosen. The documents that are assigned to both
classes are plotted surrounded by two colored circles.
The classification is performed by projecting to the first two principal
components found by PCA and CCA for visualisation purposes, followed by using
the :class:`sklearn.multiclass.OneVsRestClassifier` metaclassifier using two
SVCs with linear kernels to learn a discriminative model for each class.
Note that PCA is used to perform an unsupervised dimensionality reduction,
while CCA is used to perform a supervised one.
Note: in the plot, "unlabeled samples" does not mean that we don't know the
labels (as in semi-supervised learning) but that the samples simply do *not*
have a label.
"""
print(__doc__)
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_multilabel_classification
from sklearn.multiclass import OneVsRestClassifier
from sklearn.svm import SVC
from sklearn.preprocessing import LabelBinarizer
from sklearn.decomposition import PCA
from sklearn.cross_decomposition import CCA
def plot_hyperplane(clf, min_x, max_x, linestyle, label):
# get the separating hyperplane
w = clf.coef_[0]
a = -w[0] / w[1]
xx = np.linspace(min_x - 5, max_x + 5) # make sure the line is long enough
yy = a * xx - (clf.intercept_[0]) / w[1]
plt.plot(xx, yy, linestyle, label=label)
def plot_subfigure(X, Y, subplot, title, transform):
if transform == "pca":
X = PCA(n_components=2).fit_transform(X)
elif transform == "cca":
X = CCA(n_components=2).fit(X, Y).transform(X)
else:
raise ValueError
min_x = np.min(X[:, 0])
max_x = np.max(X[:, 0])
min_y = np.min(X[:, 1])
max_y = np.max(X[:, 1])
classif = OneVsRestClassifier(SVC(kernel='linear'))
classif.fit(X, Y)
plt.subplot(2, 2, subplot)
plt.title(title)
zero_class = np.where(Y[:, 0])
one_class = np.where(Y[:, 1])
plt.scatter(X[:, 0], X[:, 1], s=40, c='gray')
plt.scatter(X[zero_class, 0], X[zero_class, 1], s=160, edgecolors='b',
facecolors='none', linewidths=2, label='Class 1')
plt.scatter(X[one_class, 0], X[one_class, 1], s=80, edgecolors='orange',
facecolors='none', linewidths=2, label='Class 2')
plot_hyperplane(classif.estimators_[0], min_x, max_x, 'k--',
'Boundary\nfor class 1')
plot_hyperplane(classif.estimators_[1], min_x, max_x, 'k-.',
'Boundary\nfor class 2')
plt.xticks(())
plt.yticks(())
plt.xlim(min_x - .5 * max_x, max_x + .5 * max_x)
plt.ylim(min_y - .5 * max_y, max_y + .5 * max_y)
if subplot == 2:
plt.xlabel('First principal component')
plt.ylabel('Second principal component')
plt.legend(loc="upper left")
plt.figure(figsize=(8, 6))
X, Y = make_multilabel_classification(n_classes=2, n_labels=1,
allow_unlabeled=True,
random_state=1)
plot_subfigure(X, Y, 1, "With unlabeled samples + CCA", "cca")
plot_subfigure(X, Y, 2, "With unlabeled samples + PCA", "pca")
X, Y = make_multilabel_classification(n_classes=2, n_labels=1,
allow_unlabeled=False,
random_state=1)
plot_subfigure(X, Y, 3, "Without unlabeled samples + CCA", "cca")
plot_subfigure(X, Y, 4, "Without unlabeled samples + PCA", "pca")
plt.subplots_adjust(.04, .02, .97, .94, .09, .2)
plt.show()
| bsd-3-clause |
0asa/scikit-learn | sklearn/tests/test_pipeline.py | 17 | 12512 | """
Test the pipeline module.
"""
import numpy as np
from scipy import sparse
from sklearn.externals.six.moves import zip
from sklearn.utils.testing import assert_raises
from sklearn.utils.testing import assert_equal
from sklearn.utils.testing import assert_false
from sklearn.utils.testing import assert_true
from sklearn.utils.testing import assert_array_equal
from sklearn.utils.testing import assert_array_almost_equal
from sklearn.base import BaseEstimator, clone
from sklearn.pipeline import Pipeline, FeatureUnion, make_pipeline, make_union
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression
from sklearn.linear_model import LinearRegression
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.decomposition import PCA, RandomizedPCA, TruncatedSVD
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.feature_extraction.text import CountVectorizer
JUNK_FOOD_DOCS = (
"the pizza pizza beer copyright",
"the pizza burger beer copyright",
"the the pizza beer beer copyright",
"the burger beer beer copyright",
"the coke burger coke copyright",
"the coke burger burger",
)
class IncorrectT(BaseEstimator):
"""Small class to test parameter dispatching.
"""
def __init__(self, a=None, b=None):
self.a = a
self.b = b
class T(IncorrectT):
def fit(self, X, y):
return self
class TransfT(T):
def transform(self, X, y=None):
return X
class FitParamT(BaseEstimator):
"""Mock classifier
"""
def __init__(self):
self.successful = False
pass
def fit(self, X, y, should_succeed=False):
self.successful = should_succeed
def predict(self, X):
return self.successful
def test_pipeline_init():
""" Test the various init parameters of the pipeline.
"""
assert_raises(TypeError, Pipeline)
# Check that we can't instantiate pipelines with objects without fit
# method
pipe = assert_raises(TypeError, Pipeline, [('svc', IncorrectT)])
# Smoke test with only an estimator
clf = T()
pipe = Pipeline([('svc', clf)])
assert_equal(pipe.get_params(deep=True),
dict(svc__a=None, svc__b=None, svc=clf))
# Check that params are set
pipe.set_params(svc__a=0.1)
assert_equal(clf.a, 0.1)
# Smoke test the repr:
repr(pipe)
# Test with two objects
clf = SVC()
filter1 = SelectKBest(f_classif)
pipe = Pipeline([('anova', filter1), ('svc', clf)])
# Check that we can't use the same stage name twice
assert_raises(ValueError, Pipeline, [('svc', SVC()), ('svc', SVC())])
# Check that params are set
pipe.set_params(svc__C=0.1)
assert_equal(clf.C, 0.1)
# Smoke test the repr:
repr(pipe)
# Check that params are not set when naming them wrong
assert_raises(ValueError, pipe.set_params, anova__C=0.1)
# Test clone
pipe2 = clone(pipe)
assert_false(pipe.named_steps['svc'] is pipe2.named_steps['svc'])
# Check that apart from estimators, the parameters are the same
params = pipe.get_params()
params2 = pipe2.get_params()
# Remove estimators that where copied
params.pop('svc')
params.pop('anova')
params2.pop('svc')
params2.pop('anova')
assert_equal(params, params2)
def test_pipeline_methods_anova():
""" Test the various methods of the pipeline (anova).
"""
iris = load_iris()
X = iris.data
y = iris.target
# Test with Anova + LogisticRegression
clf = LogisticRegression()
filter1 = SelectKBest(f_classif, k=2)
pipe = Pipeline([('anova', filter1), ('logistic', clf)])
pipe.fit(X, y)
pipe.predict(X)
pipe.predict_proba(X)
pipe.predict_log_proba(X)
pipe.score(X, y)
def test_pipeline_fit_params():
"""Test that the pipeline can take fit parameters
"""
pipe = Pipeline([('transf', TransfT()), ('clf', FitParamT())])
pipe.fit(X=None, y=None, clf__should_succeed=True)
# classifier should return True
assert_true(pipe.predict(None))
# and transformer params should not be changed
assert_true(pipe.named_steps['transf'].a is None)
assert_true(pipe.named_steps['transf'].b is None)
def test_pipeline_methods_pca_svm():
"""Test the various methods of the pipeline (pca + svm)."""
iris = load_iris()
X = iris.data
y = iris.target
# Test with PCA + SVC
clf = SVC(probability=True, random_state=0)
pca = PCA(n_components='mle', whiten=True)
pipe = Pipeline([('pca', pca), ('svc', clf)])
pipe.fit(X, y)
pipe.predict(X)
pipe.predict_proba(X)
pipe.predict_log_proba(X)
pipe.score(X, y)
def test_pipeline_methods_preprocessing_svm():
"""Test the various methods of the pipeline (preprocessing + svm)."""
iris = load_iris()
X = iris.data
y = iris.target
n_samples = X.shape[0]
n_classes = len(np.unique(y))
scaler = StandardScaler()
pca = RandomizedPCA(n_components=2, whiten=True)
clf = SVC(probability=True, random_state=0)
for preprocessing in [scaler, pca]:
pipe = Pipeline([('preprocess', preprocessing), ('svc', clf)])
pipe.fit(X, y)
# check shapes of various prediction functions
predict = pipe.predict(X)
assert_equal(predict.shape, (n_samples,))
proba = pipe.predict_proba(X)
assert_equal(proba.shape, (n_samples, n_classes))
log_proba = pipe.predict_log_proba(X)
assert_equal(log_proba.shape, (n_samples, n_classes))
decision_function = pipe.decision_function(X)
assert_equal(decision_function.shape, (n_samples, n_classes))
pipe.score(X, y)
def test_feature_union():
# basic sanity check for feature union
iris = load_iris()
X = iris.data
X -= X.mean(axis=0)
y = iris.target
svd = TruncatedSVD(n_components=2, random_state=0)
select = SelectKBest(k=1)
fs = FeatureUnion([("svd", svd), ("select", select)])
fs.fit(X, y)
X_transformed = fs.transform(X)
assert_equal(X_transformed.shape, (X.shape[0], 3))
# check if it does the expected thing
assert_array_almost_equal(X_transformed[:, :-1], svd.fit_transform(X))
assert_array_equal(X_transformed[:, -1],
select.fit_transform(X, y).ravel())
# test if it also works for sparse input
# We use a different svd object to control the random_state stream
fs = FeatureUnion([("svd", svd), ("select", select)])
X_sp = sparse.csr_matrix(X)
X_sp_transformed = fs.fit_transform(X_sp, y)
assert_array_almost_equal(X_transformed, X_sp_transformed.toarray())
# test setting parameters
fs.set_params(select__k=2)
assert_equal(fs.fit_transform(X, y).shape, (X.shape[0], 4))
# test it works with transformers missing fit_transform
fs = FeatureUnion([("mock", TransfT()), ("svd", svd), ("select", select)])
X_transformed = fs.fit_transform(X, y)
assert_equal(X_transformed.shape, (X.shape[0], 8))
def test_make_union():
pca = PCA()
mock = TransfT()
fu = make_union(pca, mock)
names, transformers = zip(*fu.transformer_list)
assert_equal(names, ("pca", "transft"))
assert_equal(transformers, (pca, mock))
def test_pipeline_transform():
# Test whether pipeline works with a transformer at the end.
# Also test pipeline.transform and pipeline.inverse_transform
iris = load_iris()
X = iris.data
pca = PCA(n_components=2)
pipeline = Pipeline([('pca', pca)])
# test transform and fit_transform:
X_trans = pipeline.fit(X).transform(X)
X_trans2 = pipeline.fit_transform(X)
X_trans3 = pca.fit_transform(X)
assert_array_almost_equal(X_trans, X_trans2)
assert_array_almost_equal(X_trans, X_trans3)
X_back = pipeline.inverse_transform(X_trans)
X_back2 = pca.inverse_transform(X_trans)
assert_array_almost_equal(X_back, X_back2)
def test_pipeline_fit_transform():
# Test whether pipeline works with a transformer missing fit_transform
iris = load_iris()
X = iris.data
y = iris.target
transft = TransfT()
pipeline = Pipeline([('mock', transft)])
# test fit_transform:
X_trans = pipeline.fit_transform(X, y)
X_trans2 = transft.fit(X, y).transform(X)
assert_array_almost_equal(X_trans, X_trans2)
def test_make_pipeline():
t1 = TransfT()
t2 = TransfT()
pipe = make_pipeline(t1, t2)
assert_true(isinstance(pipe, Pipeline))
assert_equal(pipe.steps[0][0], "transft-1")
assert_equal(pipe.steps[1][0], "transft-2")
pipe = make_pipeline(t1, t2, FitParamT())
assert_true(isinstance(pipe, Pipeline))
assert_equal(pipe.steps[0][0], "transft-1")
assert_equal(pipe.steps[1][0], "transft-2")
assert_equal(pipe.steps[2][0], "fitparamt")
def test_feature_union_weights():
# test feature union with transformer weights
iris = load_iris()
X = iris.data
y = iris.target
pca = RandomizedPCA(n_components=2, random_state=0)
select = SelectKBest(k=1)
# test using fit followed by transform
fs = FeatureUnion([("pca", pca), ("select", select)],
transformer_weights={"pca": 10})
fs.fit(X, y)
X_transformed = fs.transform(X)
# test using fit_transform
fs = FeatureUnion([("pca", pca), ("select", select)],
transformer_weights={"pca": 10})
X_fit_transformed = fs.fit_transform(X, y)
# test it works with transformers missing fit_transform
fs = FeatureUnion([("mock", TransfT()), ("pca", pca), ("select", select)],
transformer_weights={"mock": 10})
X_fit_transformed_wo_method = fs.fit_transform(X, y)
# check against expected result
# We use a different pca object to control the random_state stream
assert_array_almost_equal(X_transformed[:, :-1], 10 * pca.fit_transform(X))
assert_array_equal(X_transformed[:, -1],
select.fit_transform(X, y).ravel())
assert_array_almost_equal(X_fit_transformed[:, :-1],
10 * pca.fit_transform(X))
assert_array_equal(X_fit_transformed[:, -1],
select.fit_transform(X, y).ravel())
assert_equal(X_fit_transformed_wo_method.shape, (X.shape[0], 7))
def test_feature_union_parallel():
# test that n_jobs work for FeatureUnion
X = JUNK_FOOD_DOCS
fs = FeatureUnion([
("words", CountVectorizer(analyzer='word')),
("chars", CountVectorizer(analyzer='char')),
])
fs_parallel = FeatureUnion([
("words", CountVectorizer(analyzer='word')),
("chars", CountVectorizer(analyzer='char')),
], n_jobs=2)
fs_parallel2 = FeatureUnion([
("words", CountVectorizer(analyzer='word')),
("chars", CountVectorizer(analyzer='char')),
], n_jobs=2)
fs.fit(X)
X_transformed = fs.transform(X)
assert_equal(X_transformed.shape[0], len(X))
fs_parallel.fit(X)
X_transformed_parallel = fs_parallel.transform(X)
assert_equal(X_transformed.shape, X_transformed_parallel.shape)
assert_array_equal(
X_transformed.toarray(),
X_transformed_parallel.toarray()
)
# fit_transform should behave the same
X_transformed_parallel2 = fs_parallel2.fit_transform(X)
assert_array_equal(
X_transformed.toarray(),
X_transformed_parallel2.toarray()
)
# transformers should stay fit after fit_transform
X_transformed_parallel2 = fs_parallel2.transform(X)
assert_array_equal(
X_transformed.toarray(),
X_transformed_parallel2.toarray()
)
def test_feature_union_feature_names():
word_vect = CountVectorizer(analyzer="word")
char_vect = CountVectorizer(analyzer="char_wb", ngram_range=(3, 3))
ft = FeatureUnion([("chars", char_vect), ("words", word_vect)])
ft.fit(JUNK_FOOD_DOCS)
feature_names = ft.get_feature_names()
for feat in feature_names:
assert_true("chars__" in feat or "words__" in feat)
assert_equal(len(feature_names), 35)
def test_classes_property():
iris = load_iris()
X = iris.data
y = iris.target
reg = make_pipeline(SelectKBest(k=1), LinearRegression())
reg.fit(X, y)
assert_raises(AttributeError, getattr, reg, "classes_")
clf = make_pipeline(SelectKBest(k=1), LogisticRegression(random_state=0))
assert_raises(AttributeError, getattr, clf, "classes_")
clf.fit(X, y)
assert_array_equal(clf.classes_, np.unique(y))
| bsd-3-clause |
DangoMelon0701/PyRemote-Sensing | NETCDF scripts/SODA3/anomalies.py | 1 | 5546 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed May 24 15:40:25 2017
@author: Gerardo A. Rivera Tello
"""
from mpl_toolkits.basemap import Basemap
import matplotlib.pyplot as plt
from scipy.io import netcdf
from osgeo import gdal,osr
import numpy as np
import os
#%%
if 'GDAL_DATA' not in os.environ:
os.environ['GDAL_DATA'] = r'/home/DangoMelon0701/anaconda3/pkgs/libgdal-2.1.0-0/share/gdal'
#%%
# Funcion para plot en el mapa
def plot_map(data,lat,lon,band=None,title=None,savefig=None,name='image'):
fig, axis = plt.subplots(figsize=(10,20))
m = Basemap(projection = 'cyl', resolution = 'l',
llcrnrlat=lat.min()-1,urcrnrlat=lat.max()+1,
llcrnrlon=lon.min()-1, urcrnrlon=lon.max()+1)
m.drawcoastlines(linewidth = 0.5)
m.drawcountries()
m.drawparallels(np.arange(-90.0,90.0,2.0), labels = [1,0,0,0])
m.drawmeridians(np.arange(-180.0,180.0,2.0), labels = [0,0,0,0],linewidth=0.5)
m.drawmeridians(np.arange(-180.0,180.0,10.0), labels = [0,0,0,1],linewidth=0.5)
x, y =m(lon, lat)
if band == None:
mmap=m.pcolormesh(x, y, data, vmin=data.min(),vmax=data.max(),cmap=plt.cm.bwr)
else:
mmap=m.pcolormesh(x, y, data[band], vmin=data.min(),vmax=data.max(),cmap=plt.cm.bwr)
cbar = m.colorbar(mmap,location='bottom',size='10%',pad='15%')
cbar.set_label('°C')
if title != None:
axis.set_title(title)
if savefig != None:
fig.savefig("{}.png".format(name),dpi=1000,bbox_inches='tight')
#%%
#Esta clase calcula las anomalias del siguiente conjunto de ecuaciones
# x = x_clim + x~
# donde
# x_clim = [x]+<x> ; [x] = promedio y <x> = estacionalidad de la variable
class Anomalies(object):
def __init__(self,data_netcdf):
self.nc_file = netcdf.NetCDFFile(data_netcdf,'r')
self.bandsn = self.nc_file.dimensions['time']
self.lines = self.nc_file.dimensions['latitude']
self.samples = self.nc_file.dimensions['longitude']
self.whole_data = np.zeros([self.bandsn,self.lines,self.samples])
self.lon,self.lat = np.meshgrid(self.nc_file.variables['longitude'][:],
self.nc_file.variables['latitude'][:])
self.temp = self.nc_file.variables['temp'][:,0]
for band in range(1,self.bandsn+1):
self.whole_data[band-1]=self.temp[band-1]
def get_whole_mean(self):
data_mean = np.zeros([self.lines,self.samples])
for band in range(1,self.bandsn+1):
data_mean +=self.whole_data[band-1]
return data_mean/self.bandsn
def get_seasonality(self,mean):
season_data = np.zeros([12,self.lines,self.samples])
global_diff = np.zeros([self.bandsn,self.lines,self.samples])
for step in range(self.bandsn):
global_diff[step]=self.whole_data[step]-mean
for month_number in range(12):
for year in range(int(self.bandsn/12)):
season_data[month_number] += global_diff[12*year+month_number]
season_data[month_number] /= 10
return season_data
def get_climvalue(self,mean,seasonality):
return mean+seasonality
def get_anomalie(self):
anomalie = np.zeros([self.bandsn,self.lines,self.samples])
mean = self.get_whole_mean()
climval = self.get_climvalue(mean,self.get_seasonality(mean))
for year in range(1,int(self.bandsn/12)+1):
anomalie[12*(year-1):12*year]=self.whole_data[12*(year-1):12*year]-climval
return anomalie
def get_anomalie_mean(self,anomalie):
anomalie_mean = np.zeros([self.lines,self.samples])
for band in range(self.bandsn):
anomalie_mean +=anomalie[band]
return anomalie_mean/self.bandsn
def save_tiff(self,file,data,raster_out="stacked_data.tif"):
#Genero el tiff de salida
driver = gdal.GetDriverByName('GTiff')
outRaster = driver.Create(raster_out, self.samples, self.lines, self.bandsn, gdal.GDT_Float32)
gdal_file = gdal.Open(file)
outRaster.SetGeoTransform(gdal_file.GetGeoTransform())
for band in range(1,self.bandsn+1):
outband = outRaster.GetRasterBand(band)
outband.WriteArray(data[band-1])
outRasterSRS = osr.SpatialReference()
outRasterSRS.ImportFromEPSG(4326)
outRaster.SetProjection(outRasterSRS.ExportToWkt())
outband.FlushCache()
del outRaster, outRasterSRS, gdal_file
def end_anom(self):
self.nc_file.close()
#%%
if __name__ == '__main__':
files_list=[]
for files in os.listdir(os.getcwd()):
if files.endswith(".nc"):
files_list.append(files)
for f_netcdf in files_list:
calc = Anomalies(f_netcdf)
anom = calc.get_anomalie()
anom_mean = calc.get_anomalie_mean(anom)
calc.save_tiff(f_netcdf,anom,raster_out='ptemp_stacked.tif')
#%%
plot_map(anom_mean,calc.lat,calc.lon,
title='Anomalies Mean from Jan2000 to Dec2009 - El Nino Zone 4',
savefig=1,name='mean_anomalies')
plot_map(anom,calc.lat,calc.lon,band=0,
title='Potential Temperature Anomalie from Jan2000 - El Nino Zone 4',
savefig=1,name='anom_jan2000en4')
plot_map(anom,calc.lat,calc.lon,band=24,
title='Potential Temperature Anomalies from Jan2002 - El Nino Zone 4',
savefig=1,name='anom_jan2002en4')
calc.end_anom() | mit |
basnijholt/holoviews | holoviews/element/comparison.py | 2 | 26491 | """
Helper classes for comparing the equality of two HoloViews objects.
These classes are designed to integrate with unittest.TestCase (see
the tests directory) while making equality testing easily accessible
to the user.
For instance, to test if two Matrix objects are equal you can use:
Comparison.assertEqual(matrix1, matrix2)
This will raise an AssertionError if the two matrix objects are not
equal, including information regarding what exactly failed to match.
Note that this functionality could not be provided using comparison
methods on all objects as comparison operators only return Booleans and
thus would not supply any information regarding *why* two elements are
considered different.
"""
from functools import partial
import numpy as np
from unittest.util import safe_repr
from unittest import TestCase
from numpy.testing import assert_array_equal, assert_array_almost_equal
from . import * # noqa (All Elements need to support comparison)
from ..core import (Element, Empty, AdjointLayout, Overlay, Dimension,
HoloMap, Dimensioned, Layout, NdLayout, NdOverlay,
GridSpace, DynamicMap, GridMatrix, OrderedDict)
from ..core.options import Options, Cycle
from ..core.util import pd, datetime_types, dt_to_int
class ComparisonInterface(object):
"""
This class is designed to allow equality testing to work
seamlessly with unittest.TestCase as a mix-in by implementing a
compatible interface (namely the assertEqual method).
The assertEqual class method is to be overridden by an instance
method of the same name when used as a mix-in with TestCase. The
contents of the equality_type_funcs dictionary is suitable for use
with TestCase.addTypeEqualityFunc.
"""
equality_type_funcs = {}
failureException = AssertionError
@classmethod
def simple_equality(cls, first, second, msg=None):
"""
Classmethod equivalent to unittest.TestCase method (longMessage = False.)
"""
if not first==second:
standardMsg = '%s != %s' % (safe_repr(first), safe_repr(second))
raise cls.failureException(msg or standardMsg)
@classmethod
def assertEqual(cls, first, second, msg=None):
"""
Classmethod equivalent to unittest.TestCase method
"""
asserter = None
if type(first) is type(second):
asserter = cls.equality_type_funcs.get(type(first))
try: basestring = basestring # Python 2
except NameError: basestring = str # Python 3
if asserter is not None:
if isinstance(asserter, basestring):
asserter = getattr(cls, asserter)
if asserter is None:
asserter = cls.simple_equality
if msg is None:
asserter(first, second)
else:
asserter(first, second, msg=msg)
class Comparison(ComparisonInterface):
"""
Class used for comparing two HoloViews objects, including complex
composite objects. Comparisons are available as classmethods, the
most general being the assertEqual method that is intended to work
with any input.
For instance, to test if two Image objects are equal you can use:
Comparison.assertEqual(matrix1, matrix2)
"""
# someone might prefer to use a different function, e.g. assert_all_close
assert_array_almost_equal_fn = partial(assert_array_almost_equal, decimal=6)
@classmethod
def register(cls):
# Float comparisons
cls.equality_type_funcs[float] = cls.compare_floats
cls.equality_type_funcs[np.float] = cls.compare_floats
cls.equality_type_funcs[np.float32] = cls.compare_floats
cls.equality_type_funcs[np.float64] = cls.compare_floats
# List and tuple comparisons
cls.equality_type_funcs[list] = cls.compare_lists
cls.equality_type_funcs[tuple] = cls.compare_tuples
# Dictionary comparisons
cls.equality_type_funcs[dict] = cls.compare_dictionaries
cls.equality_type_funcs[OrderedDict] = cls.compare_dictionaries
# Numpy array comparison
cls.equality_type_funcs[np.ndarray] = cls.compare_arrays
cls.equality_type_funcs[np.ma.masked_array] = cls.compare_arrays
# Pandas dataframe comparison
if pd:
cls.equality_type_funcs[pd.DataFrame] = cls.compare_dataframe
# Dimension objects
cls.equality_type_funcs[Dimension] = cls.compare_dimensions
cls.equality_type_funcs[Dimensioned] = cls.compare_dimensioned # Used in unit tests
cls.equality_type_funcs[Element] = cls.compare_elements # Used in unit tests
# Composition (+ and *)
cls.equality_type_funcs[Overlay] = cls.compare_overlays
cls.equality_type_funcs[Layout] = cls.compare_layouttrees
cls.equality_type_funcs[Empty] = cls.compare_empties
# Annotations
cls.equality_type_funcs[VLine] = cls.compare_vline
cls.equality_type_funcs[HLine] = cls.compare_hline
cls.equality_type_funcs[Spline] = cls.compare_spline
cls.equality_type_funcs[Arrow] = cls.compare_arrow
cls.equality_type_funcs[Text] = cls.compare_text
cls.equality_type_funcs[Div] = cls.compare_div
# Path comparisons
cls.equality_type_funcs[Path] = cls.compare_paths
cls.equality_type_funcs[Contours] = cls.compare_contours
cls.equality_type_funcs[Polygons] = cls.compare_polygons
cls.equality_type_funcs[Box] = cls.compare_box
cls.equality_type_funcs[Ellipse] = cls.compare_ellipse
cls.equality_type_funcs[Bounds] = cls.compare_bounds
# Rasters
cls.equality_type_funcs[Image] = cls.compare_image
cls.equality_type_funcs[RGB] = cls.compare_rgb
cls.equality_type_funcs[HSV] = cls.compare_hsv
cls.equality_type_funcs[Raster] = cls.compare_raster
cls.equality_type_funcs[QuadMesh] = cls.compare_quadmesh
cls.equality_type_funcs[Surface] = cls.compare_surface
cls.equality_type_funcs[HeatMap] = cls.compare_dataset
# Charts
cls.equality_type_funcs[Dataset] = cls.compare_dataset
cls.equality_type_funcs[Curve] = cls.compare_curve
cls.equality_type_funcs[ErrorBars] = cls.compare_errorbars
cls.equality_type_funcs[Spread] = cls.compare_spread
cls.equality_type_funcs[Area] = cls.compare_area
cls.equality_type_funcs[Scatter] = cls.compare_scatter
cls.equality_type_funcs[Scatter3D] = cls.compare_scatter3d
cls.equality_type_funcs[TriSurface] = cls.compare_trisurface
cls.equality_type_funcs[Trisurface] = cls.compare_trisurface
cls.equality_type_funcs[Histogram] = cls.compare_histogram
cls.equality_type_funcs[Bars] = cls.compare_bars
cls.equality_type_funcs[Spikes] = cls.compare_spikes
cls.equality_type_funcs[BoxWhisker] = cls.compare_boxwhisker
cls.equality_type_funcs[VectorField] = cls.compare_vectorfield
# Graphs
cls.equality_type_funcs[Graph] = cls.compare_graph
cls.equality_type_funcs[Nodes] = cls.compare_nodes
cls.equality_type_funcs[EdgePaths] = cls.compare_edgepaths
cls.equality_type_funcs[TriMesh] = cls.compare_trimesh
# Tables
cls.equality_type_funcs[ItemTable] = cls.compare_itemtables
cls.equality_type_funcs[Table] = cls.compare_tables
cls.equality_type_funcs[Points] = cls.compare_points
# Statistical
cls.equality_type_funcs[Bivariate] = cls.compare_bivariate
cls.equality_type_funcs[Distribution] = cls.compare_distribution
cls.equality_type_funcs[HexTiles] = cls.compare_hextiles
# NdMappings
cls.equality_type_funcs[NdLayout] = cls.compare_gridlayout
cls.equality_type_funcs[AdjointLayout] = cls.compare_adjointlayouts
cls.equality_type_funcs[NdOverlay] = cls.compare_ndoverlays
cls.equality_type_funcs[GridSpace] = cls.compare_grids
cls.equality_type_funcs[GridMatrix] = cls.compare_grids
cls.equality_type_funcs[HoloMap] = cls.compare_holomap
cls.equality_type_funcs[DynamicMap] = cls.compare_dynamicmap
# Option objects
cls.equality_type_funcs[Options] = cls.compare_options
cls.equality_type_funcs[Cycle] = cls.compare_cycles
return cls.equality_type_funcs
@classmethod
def compare_dictionaries(cls, d1, d2, msg='Dictionaries'):
keys= set(d1.keys())
keys2 = set(d2.keys())
symmetric_diff = keys ^ keys2
if symmetric_diff:
msg = ("Dictionaries have different sets of keys: %r\n\n"
% symmetric_diff)
msg += "Dictionary 1: %s\n" % d1
msg += "Dictionary 2: %s" % d2
raise cls.failureException(msg)
for k in keys:
cls.assertEqual(d1[k], d2[k])
@classmethod
def compare_lists(cls, l1, l2, msg=None):
try:
cls.assertEqual(len(l1), len(l2))
for v1, v2 in zip(l1, l2):
cls.assertEqual(v1, v2)
except AssertionError:
raise AssertionError(msg or '%s != %s' % (repr(l1), repr(l2)))
@classmethod
def compare_tuples(cls, t1, t2, msg=None):
try:
cls.assertEqual(len(t1), len(t2))
for i1, i2 in zip(t1, t2):
cls.assertEqual(i1, i2)
except AssertionError:
raise AssertionError(msg or '%s != %s' % (repr(t1), repr(t2)))
#=====================#
# Literal comparisons #
#=====================#
@classmethod
def compare_floats(cls, arr1, arr2, msg='Floats'):
cls.compare_arrays(arr1, arr2, msg)
@classmethod
def compare_arrays(cls, arr1, arr2, msg='Arrays'):
try:
if arr1.dtype.kind == 'M':
arr1 = arr1.astype('datetime64[ns]').astype('int64')
if arr2.dtype.kind == 'M':
arr2 = arr2.astype('datetime64[ns]').astype('int64')
assert_array_equal(arr1, arr2)
except:
try:
cls.assert_array_almost_equal_fn(arr1, arr2)
except AssertionError as e:
raise cls.failureException(msg + str(e)[11:])
@classmethod
def bounds_check(cls, el1, el2, msg=None):
lbrt1 = el1.bounds.lbrt()
lbrt2 = el2.bounds.lbrt()
try:
for v1, v2 in zip(lbrt1, lbrt2):
if isinstance(v1, datetime_types):
v1 = dt_to_int(v1)
if isinstance(v2, datetime_types):
v2 = dt_to_int(v2)
cls.assert_array_almost_equal_fn(v1, v2)
except AssertionError:
raise cls.failureException("BoundingBoxes are mismatched: %s != %s."
% (el1.bounds.lbrt(), el2.bounds.lbrt()))
#=======================================#
# Dimension and Dimensioned comparisons #
#=======================================#
@classmethod
def compare_dimensions(cls, dim1, dim2, msg=None):
# 'Weak' equality semantics
if dim1.name != dim2.name:
raise cls.failureException("Dimension names mismatched: %s != %s"
% (dim1.name, dim2.name))
if dim1.label != dim2.label:
raise cls.failureException("Dimension labels mismatched: %s != %s"
% (dim1.label, dim2.label))
# 'Deep' equality of dimension metadata (all parameters)
dim1_params = dict(dim1.get_param_values())
dim2_params = dict(dim2.get_param_values())
# Special handling of deprecated 'initial' values argument
dim1_params['values'] = [] if dim1.values=='initial' else dim1.values
dim2_params['values'] = [] if dim2.values=='initial' else dim2.values
if set(dim1_params.keys()) != set(dim2_params.keys()):
raise cls.failureException("Dimension parameter sets mismatched: %s != %s"
% (set(dim1_params.keys()), set(dim2_params.keys())))
for k in dim1_params.keys():
if (dim1.params(k).__class__.__name__ == 'Callable'
and dim2.params(k).__class__.__name__ == 'Callable'):
continue
try: # This is needed as two lists are not compared by contents using ==
cls.assertEqual(dim1_params[k], dim2_params[k], msg=None)
except AssertionError as e:
msg = 'Dimension parameter %r mismatched: ' % k
raise cls.failureException("%s%s" % (msg, str(e)))
@classmethod
def compare_labelled_data(cls, obj1, obj2, msg=None):
cls.assertEqual(obj1.group, obj2.group, "Group labels mismatched.")
cls.assertEqual(obj1.label, obj2.label, "Labels mismatched.")
@classmethod
def compare_dimension_lists(cls, dlist1, dlist2, msg='Dimension lists'):
if len(dlist1) != len(dlist2):
raise cls.failureException('%s mismatched' % msg)
for d1, d2 in zip(dlist1, dlist2):
cls.assertEqual(d1, d2)
@classmethod
def compare_dimensioned(cls, obj1, obj2, msg=None):
cls.compare_labelled_data(obj1, obj2)
cls.compare_dimension_lists(obj1.vdims, obj2.vdims,
'Value dimension list')
cls.compare_dimension_lists(obj1.kdims, obj2.kdims,
'Key dimension list')
@classmethod
def compare_elements(cls, obj1, obj2, msg=None):
cls.compare_labelled_data(obj1, obj2)
cls.assertEqual(obj1.data, obj2.data)
#===============================#
# Compositional trees (+ and *) #
#===============================#
@classmethod
def compare_trees(cls, el1, el2, msg='Trees'):
if len(el1.keys()) != len(el2.keys()):
raise cls.failureException("%s have mismatched path counts." % msg)
if el1.keys() != el2.keys():
raise cls.failureException("%s have mismatched paths." % msg)
for element1, element2 in zip(el1.values(), el2.values()):
cls.assertEqual(element1, element2)
@classmethod
def compare_layouttrees(cls, el1, el2, msg=None):
cls.compare_dimensioned(el1, el2)
cls.compare_trees(el1, el2, msg='Layouts')
@classmethod
def compare_empties(cls, el1, el2, msg=None):
if not all(isinstance(el, Empty) for el in [el1, el2]):
raise cls.failureException("Compared elements are not both Empty()")
@classmethod
def compare_overlays(cls, el1, el2, msg=None):
cls.compare_dimensioned(el1, el2)
cls.compare_trees(el1, el2, msg='Overlays')
#================================#
# AttrTree and Map based classes #
#================================#
@classmethod
def compare_ndmappings(cls, el1, el2, msg='NdMappings'):
cls.compare_dimensioned(el1, el2)
if len(el1.keys()) != len(el2.keys()):
raise cls.failureException("%s have different numbers of keys." % msg)
if set(el1.keys()) != set(el2.keys()):
diff1 = [el for el in el1.keys() if el not in el2.keys()]
diff2 = [el for el in el2.keys() if el not in el1.keys()]
raise cls.failureException("%s have different sets of keys. " % msg
+ "In first, not second %s. " % diff1
+ "In second, not first: %s." % diff2)
for element1, element2 in zip(el1, el2):
cls.assertEqual(element1, element2)
@classmethod
def compare_holomap(cls, el1, el2, msg='HoloMaps'):
cls.compare_dimensioned(el1, el2)
cls.compare_ndmappings(el1, el2, msg)
@classmethod
def compare_dynamicmap(cls, el1, el2, msg='DynamicMap'):
cls.compare_dimensioned(el1, el2)
cls.compare_ndmappings(el1, el2, msg)
@classmethod
def compare_gridlayout(cls, el1, el2, msg=None):
cls.compare_dimensioned(el1, el2)
if len(el1) != len(el2):
raise cls.failureException("Layouts have different sizes.")
if set(el1.keys()) != set(el2.keys()):
raise cls.failureException("Layouts have different keys.")
for element1, element2 in zip(el1, el2):
cls.assertEqual(element1,element2)
@classmethod
def compare_ndoverlays(cls, el1, el2, msg=None):
cls.compare_dimensioned(el1, el2)
if len(el1) != len(el2):
raise cls.failureException("NdOverlays have different lengths.")
for (layer1, layer2) in zip(el1, el2):
cls.assertEqual(layer1, layer2)
@classmethod
def compare_adjointlayouts(cls, el1, el2, msg=None):
cls.compare_dimensioned(el1, el2)
for element1, element2 in zip(el1, el1):
cls.assertEqual(element1, element2)
#=============#
# Annotations #
#=============#
@classmethod
def compare_annotation(cls, el1, el2, msg='Annotation'):
cls.compare_dimensioned(el1, el2)
cls.assertEqual(el1.data, el2.data)
@classmethod
def compare_hline(cls, el1, el2, msg='HLine'):
cls.compare_annotation(el1, el2, msg=msg)
@classmethod
def compare_vline(cls, el1, el2, msg='VLine'):
cls.compare_annotation(el1, el2, msg=msg)
@classmethod
def compare_spline(cls, el1, el2, msg='Spline'):
cls.compare_annotation(el1, el2, msg=msg)
@classmethod
def compare_arrow(cls, el1, el2, msg='Arrow'):
cls.compare_annotation(el1, el2, msg=msg)
@classmethod
def compare_text(cls, el1, el2, msg='Text'):
cls.compare_annotation(el1, el2, msg=msg)
@classmethod
def compare_div(cls, el1, el2, msg='Div'):
cls.compare_annotation(el1, el2, msg=msg)
#=======#
# Paths #
#=======#
@classmethod
def compare_paths(cls, el1, el2, msg='Path'):
cls.compare_dataset(el1, el2, msg)
paths1 = el1.split()
paths2 = el2.split()
if len(paths1) != len(paths2):
raise cls.failureException("%s objects do not have a matching number of paths." % msg)
for p1, p2 in zip(paths1, paths2):
cls.compare_dataset(p1, p2, '%s data' % msg)
@classmethod
def compare_contours(cls, el1, el2, msg='Contours'):
cls.compare_paths(el1, el2, msg=msg)
@classmethod
def compare_polygons(cls, el1, el2, msg='Polygons'):
cls.compare_paths(el1, el2, msg=msg)
@classmethod
def compare_box(cls, el1, el2, msg='Box'):
cls.compare_paths(el1, el2, msg=msg)
@classmethod
def compare_ellipse(cls, el1, el2, msg='Ellipse'):
cls.compare_paths(el1, el2, msg=msg)
@classmethod
def compare_bounds(cls, el1, el2, msg='Bounds'):
cls.compare_paths(el1, el2, msg=msg)
#========#
# Charts #
#========#
@classmethod
def compare_dataset(cls, el1, el2, msg='Dataset'):
cls.compare_dimensioned(el1, el2)
if el1.shape[0] != el2.shape[0]:
raise AssertionError("%s not of matching length." % msg)
dimension_data = [(d, el1[d], el2[d]) for d in el1.dimensions()]
for dim, d1, d2 in dimension_data:
if d1.dtype != d2.dtype:
cls.failureException("%s %s columns have different type." % (msg, dim.pprint_label)
+ " First has type %s, and second has type %s."
% (d1, d2))
if d1.dtype.kind in 'SUOV':
if list(d1) == list(d2):
cls.failureException("%s along dimension %s not equal." %
(msg, dim.pprint_label))
else:
cls.compare_arrays(d1, d2, msg)
@classmethod
def compare_curve(cls, el1, el2, msg='Curve'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_errorbars(cls, el1, el2, msg='ErrorBars'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_spread(cls, el1, el2, msg='Spread'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_area(cls, el1, el2, msg='Area'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_scatter(cls, el1, el2, msg='Scatter'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_scatter3d(cls, el1, el2, msg='Scatter3D'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_trisurface(cls, el1, el2, msg='TriSurface'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_histogram(cls, el1, el2, msg='Histogram'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_points(cls, el1, el2, msg='Points'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_vectorfield(cls, el1, el2, msg='VectorField'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_bars(cls, el1, el2, msg='Bars'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_spikes(cls, el1, el2, msg='Spikes'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_boxwhisker(cls, el1, el2, msg='BoxWhisker'):
cls.compare_dataset(el1, el2, msg)
#=========#
# Graphs #
#=========#
@classmethod
def compare_graph(cls, el1, el2, msg='Graph'):
cls.compare_dataset(el1, el2, msg)
cls.compare_nodes(el1.nodes, el2.nodes, msg)
if el1._edgepaths or el2._edgepaths:
cls.compare_edgepaths(el1.edgepaths, el2.edgepaths, msg)
@classmethod
def compare_trimesh(cls, el1, el2, msg='TriMesh'):
cls.compare_graph(el1, el2, msg)
@classmethod
def compare_nodes(cls, el1, el2, msg='Nodes'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_edgepaths(cls, el1, el2, msg='Nodes'):
cls.compare_paths(el1, el2, msg)
#=========#
# Rasters #
#=========#
@classmethod
def compare_raster(cls, el1, el2, msg='Raster'):
cls.compare_dimensioned(el1, el2)
cls.compare_arrays(el1.data, el2.data, msg)
@classmethod
def compare_quadmesh(cls, el1, el2, msg='QuadMesh'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_heatmap(cls, el1, el2, msg='HeatMap'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_image(cls, el1, el2, msg='Image'):
cls.bounds_check(el1,el2)
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_rgb(cls, el1, el2, msg='RGB'):
cls.bounds_check(el1,el2)
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_hsv(cls, el1, el2, msg='HSV'):
cls.bounds_check(el1,el2)
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_surface(cls, el1, el2, msg='Surface'):
cls.bounds_check(el1,el2)
cls.compare_dataset(el1, el2, msg)
#========#
# Tables #
#========#
@classmethod
def compare_itemtables(cls, el1, el2, msg=None):
cls.compare_dimensioned(el1, el2)
if el1.rows != el2.rows:
raise cls.failureException("ItemTables have different numbers of rows.")
if el1.cols != el2.cols:
raise cls.failureException("ItemTables have different numbers of columns.")
if [d.name for d in el1.vdims] != [d.name for d in el2.vdims]:
raise cls.failureException("ItemTables have different Dimensions.")
@classmethod
def compare_tables(cls, el1, el2, msg='Table'):
cls.compare_dataset(el1, el2, msg)
#========#
# Pandas #
#========#
@classmethod
def compare_dataframe(cls, df1, df2, msg='DFrame'):
from pandas.util.testing import assert_frame_equal
try:
assert_frame_equal(df1, df2)
except AssertionError as e:
raise cls.failureException(msg+': '+str(e))
#============#
# Statistics #
#============#
@classmethod
def compare_distribution(cls, el1, el2, msg='Distribution'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_bivariate(cls, el1, el2, msg='Bivariate'):
cls.compare_dataset(el1, el2, msg)
@classmethod
def compare_hextiles(cls, el1, el2, msg='HexTiles'):
cls.compare_dataset(el1, el2, msg)
#=======#
# Grids #
#=======#
@classmethod
def _compare_grids(cls, el1, el2, name):
if len(el1.keys()) != len(el2.keys()):
raise cls.failureException("%ss have different numbers of items." % name)
if set(el1.keys()) != set(el2.keys()):
raise cls.failureException("%ss have different keys." % name)
if len(el1) != len(el2):
raise cls.failureException("%ss have different depths." % name)
for element1, element2 in zip(el1, el2):
cls.assertEqual(element1, element2)
@classmethod
def compare_grids(cls, el1, el2, msg=None):
cls.compare_dimensioned(el1, el2)
cls._compare_grids(el1, el2, 'GridSpace')
#=========#
# Options #
#=========#
@classmethod
def compare_options(cls, options1, options2, msg=None):
cls.assertEqual(options1.kwargs, options2.kwargs)
@classmethod
def compare_cycles(cls, cycle1, cycle2, msg=None):
cls.assertEqual(cycle1.values, cycle2.values)
@classmethod
def compare_channelopts(cls, opt1, opt2, msg=None):
cls.assertEqual(opt1.mode, opt2.mode)
cls.assertEqual(opt1.pattern, opt2.pattern)
cls.assertEqual(opt1.patter, opt2.pattern)
class ComparisonTestCase(Comparison, TestCase):
"""
Class to integrate the Comparison class with unittest.TestCase.
"""
def __init__(self, *args, **kwargs):
TestCase.__init__(self, *args, **kwargs)
registry = Comparison.register()
for k, v in registry.items():
self.addTypeEqualityFunc(k, v)
| bsd-3-clause |
abhishekgahlot/scikit-learn | examples/decomposition/plot_ica_blind_source_separation.py | 349 | 2228 | """
=====================================
Blind source separation using FastICA
=====================================
An example of estimating sources from noisy data.
:ref:`ICA` is used to estimate sources given noisy measurements.
Imagine 3 instruments playing simultaneously and 3 microphones
recording the mixed signals. ICA is used to recover the sources
ie. what is played by each instrument. Importantly, PCA fails
at recovering our `instruments` since the related signals reflect
non-Gaussian processes.
"""
print(__doc__)
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal
from sklearn.decomposition import FastICA, PCA
###############################################################################
# Generate sample data
np.random.seed(0)
n_samples = 2000
time = np.linspace(0, 8, n_samples)
s1 = np.sin(2 * time) # Signal 1 : sinusoidal signal
s2 = np.sign(np.sin(3 * time)) # Signal 2 : square signal
s3 = signal.sawtooth(2 * np.pi * time) # Signal 3: saw tooth signal
S = np.c_[s1, s2, s3]
S += 0.2 * np.random.normal(size=S.shape) # Add noise
S /= S.std(axis=0) # Standardize data
# Mix data
A = np.array([[1, 1, 1], [0.5, 2, 1.0], [1.5, 1.0, 2.0]]) # Mixing matrix
X = np.dot(S, A.T) # Generate observations
# Compute ICA
ica = FastICA(n_components=3)
S_ = ica.fit_transform(X) # Reconstruct signals
A_ = ica.mixing_ # Get estimated mixing matrix
# We can `prove` that the ICA model applies by reverting the unmixing.
assert np.allclose(X, np.dot(S_, A_.T) + ica.mean_)
# For comparison, compute PCA
pca = PCA(n_components=3)
H = pca.fit_transform(X) # Reconstruct signals based on orthogonal components
###############################################################################
# Plot results
plt.figure()
models = [X, S, S_, H]
names = ['Observations (mixed signal)',
'True Sources',
'ICA recovered signals',
'PCA recovered signals']
colors = ['red', 'steelblue', 'orange']
for ii, (model, name) in enumerate(zip(models, names), 1):
plt.subplot(4, 1, ii)
plt.title(name)
for sig, color in zip(model.T, colors):
plt.plot(sig, color=color)
plt.subplots_adjust(0.09, 0.04, 0.94, 0.94, 0.26, 0.46)
plt.show()
| bsd-3-clause |
cangermueller/deepcpg | scripts/dcpg_train.py | 1 | 28511 | #!/usr/bin/env python
"""Train a DeepCpG model to predict DNA methylation.
Trains a DeepCpG model on DNA (DNA model), neighboring methylation states
(CpG model), or both (Joint model) to predict CpG methylation of multiple cells.
Allows to fine-tune individual models or to train them from scratch.
Examples
--------
Train a DNA model on chromosome 1, 3, and 5, and use chromosome 13, 14, and
15 for validation:
.. code:: bash
dcpg_train.py
./data/c{1,3,5}_*.h5
--val_files ./data/c{13,14,15}_*.h5
--dna_model CnnL2h128
--out_dir ./models/dna
Train a CpG model:
.. code:: bash
dcpg_train.py
./data/c{1,3,5}_*.h5
--val_files ./data/c{13,14,15}_*.h5
--cpg_model RnnL1
--out_dir ./models/cpg
Train a Joint model using a pre-trained DNA and CpG model:
.. code:: bash
dcpg_train.py
./data/c{1,3,5}_*.h5
--val_files ./data/c{13,14,15}_*.h5
--dna_model ./models/dna
--cpg_model ./models/cpg
--joint_model JointL2h512
--train_models joint
--out_dir ./models/joint
See Also
--------
* ``dcpg_eval.py``: For evaluating a trained model and imputing methylation
profiles.
"""
from __future__ import print_function
from __future__ import division
from collections import OrderedDict
import os
import random
import re
import sys
import argparse
import h5py as h5
import logging
import numpy as np
import pandas as pd
import six
from six.moves import range
from keras import callbacks as kcbk
from keras.models import Model
from keras.optimizers import Adam
from deepcpg import callbacks as cbk
from deepcpg import data as dat
from deepcpg import metrics as met
from deepcpg import models as mod
from deepcpg.models.utils import is_input_layer, is_output_layer
from deepcpg.data import hdf, OUTPUT_SEP
from deepcpg.utils import format_table, make_dir, EPS
LOG_PRECISION = 4
CLA_METRICS = [met.acc]
REG_METRICS = [met.mse, met.mae]
def remove_outputs(model):
while is_output_layer(model.layers[-1], model):
model.layers.pop()
model.outputs = [model.layers[-1].output]
model.layers[-1].outbound_nodes = []
model.output_names = None
def rename_layers(model, scope=None):
if not scope:
scope = model.scope
for layer in model.layers:
if is_input_layer(layer) or layer.name.startswith(scope):
continue
layer.name = '%s/%s' % (scope, layer.name)
def get_output_stats(output):
stats = OrderedDict()
output = np.ma.masked_values(output, dat.CPG_NAN)
stats['nb_tot'] = len(output)
stats['nb_obs'] = np.sum(output != dat.CPG_NAN)
stats['frac_obs'] = stats['nb_obs'] / stats['nb_tot']
stats['mean'] = float(np.mean(output))
stats['var'] = float(np.var(output))
return stats
def get_output_weights(output_names, weight_patterns):
regex_weights = dict()
for weight_pattern in weight_patterns:
tmp = [tmp.strip() for tmp in weight_pattern.split('=')]
if len(tmp) != 2:
raise ValueError('Invalid weight pattern "%s"!' % (weight_pattern))
regex_weights[tmp[0]] = float(tmp[1])
output_weights = dict()
for output_name in output_names:
for regex, weight in six.iteritems(regex_weights):
if re.match(regex, output_name):
output_weights[output_name] = weight
if output_name not in output_weights:
output_weights[output_name] = 1.0
return output_weights
def get_class_weights(labels, nb_class=None):
freq = np.bincount(labels) / len(labels)
if nb_class is None:
nb_class = len(freq)
if len(freq) < nb_class:
tmp = np.zeros(nb_class, dtype=freq.dtype)
tmp[:len(freq)] = freq
freq = tmp
weights = 1 / (freq + EPS)
weights /= weights.sum()
return weights
def get_output_class_weights(output_name, output):
output = output[output != dat.CPG_NAN]
_output_name = output_name.split(OUTPUT_SEP)
if _output_name[0] == 'cpg':
weights = get_class_weights(output, 2)
elif _output_name[-1] == 'cat_var':
weights = get_class_weights(output, 3)
elif _output_name[-1] in ['cat2_var', 'diff', 'mode']:
weights = get_class_weights(output, 2)
else:
return None
weights = OrderedDict(zip(range(len(weights)), weights))
return weights
def perf_logs_str(logs):
t = logs.to_csv(None, sep='\t', float_format='%.4f', index=False)
return t
def get_metrics(output_name):
_output_name = output_name.split(OUTPUT_SEP)
if _output_name[0] == 'cpg':
metrics = CLA_METRICS
elif _output_name[0] == 'bulk':
metrics = REG_METRICS + CLA_METRICS
elif _output_name[-1] in ['diff', 'mode', 'cat2_var']:
metrics = CLA_METRICS
elif _output_name[-1] == 'mean':
metrics = REG_METRICS + CLA_METRICS
elif _output_name[-1] == 'var':
metrics = REG_METRICS
elif _output_name[-1] == 'cat_var':
metrics = [met.cat_acc]
else:
raise ValueError('Invalid output name "%s"!' % output_name)
return metrics
class App(object):
def run(self, args):
name = os.path.basename(args[0])
parser = self.create_parser(name)
opts = parser.parse_args(args[1:])
return self.main(name, opts)
def create_parser(self, name):
p = argparse.ArgumentParser(
prog=name,
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
description='Trains model on DNA (DNA model), neighboring '
'methylation states (CpG model), or both (Joint model) to predict '
'CpG methylation of multiple cells.')
# IO
g = p.add_argument_group('input-output arguments')
g.add_argument(
'train_files',
nargs='+',
help='Training data files')
g.add_argument(
'--val_files',
nargs='+',
help='Validation data files')
g.add_argument(
'-o', '--out_dir',
default='./train',
help='Output directory')
g = p.add_argument_group('arguments to define the model architecture')
models = sorted(list(mod.dna.list_models().keys()))
g.add_argument(
'--dna_model',
help='Name of DNA model or files of existing model.'
' Available models: %s' % ', '.join(models),
nargs='+')
g.add_argument(
'--dna_wlen',
help='DNA window length',
type=int)
models = sorted(list(mod.cpg.list_models().keys()))
g.add_argument(
'--cpg_model',
help='Name of CpG model or files of existing model.'
' Available models: %s' % ', '.join(models),
nargs='+')
g.add_argument(
'--cpg_wlen',
help='CpG window length',
type=int)
models = sorted(list(mod.joint.list_models().keys()))
g.add_argument(
'--joint_model',
help='Name of Joint model.'
' Available models: %s' % ', '.join(models),
default='JointL2h512')
g.add_argument(
'--model_files',
help='Files of existing model',
nargs='+')
g = p.add_argument_group('arguments to define which model components '
'are trained')
g.add_argument(
'--fine_tune',
help='Only train output layers',
action='store_true')
g.add_argument(
'--train_models',
help='Only train the specified models',
choices=['dna', 'cpg', 'joint'],
nargs='+')
g.add_argument(
'--trainable',
help='Regex of layers that should be trained',
nargs='+')
g.add_argument(
'--not_trainable',
help='Regex of layers that should not be trained',
nargs='+')
g.add_argument(
'--freeze_filter',
help='Exclude filter weights of first convolutional layer from '
'training',
action='store_true')
g.add_argument(
'--filter_weights',
help='HDF5 file with weights to be used for initializing filters',
nargs='+')
g = p.add_argument_group('training arguments')
g.add_argument(
'--learning_rate',
help='Learning rate',
type=float,
default=0.0001)
g.add_argument(
'--learning_rate_decay',
help='Exponential learning rate decay factor',
type=float,
default=0.975)
g.add_argument(
'--nb_epoch',
help='Maximum # training epochs',
type=int,
default=30)
g.add_argument(
'--nb_train_sample',
help='Maximum # training samples',
type=int)
g.add_argument(
'--nb_val_sample',
help='Maximum # validation samples',
type=int)
g.add_argument(
'--batch_size',
help='Batch size',
type=int,
default=128)
g.add_argument(
'--early_stopping',
help='Early stopping patience',
type=int,
default=5)
g.add_argument(
'--dropout',
help='Dropout rate',
type=float,
default=0.0)
g.add_argument(
'--l1_decay',
help='L1 weight decay',
type=float,
default=0.0001)
g.add_argument(
'--l2_decay',
help='L2 weight decay',
type=float,
default=0.0001)
g.add_argument(
'--no_tensorboard',
help='Do not store Tensorboard summaries',
action='store_true')
g = p.add_argument_group('arguments to select outputs and weights')
g.add_argument(
'--output_names',
help='Regex to select outputs',
nargs='+',
default=['cpg/.*'])
g.add_argument(
'--nb_output',
type=int,
help='Maximum number of outputs')
g.add_argument(
'--no_class_weights',
help='Do not weight classes',
action='store_true')
g.add_argument(
'--output_weights',
help='Output weights defined as a list of `output`=`weight` '
'patterns, where `output` is a regex of output names, and '
'`weight` the weight that is assigned to them',
nargs='+')
g.add_argument(
'--replicate_names',
help='Regex to select replicates',
nargs='+')
g.add_argument(
'--nb_replicate',
type=int,
help='Maximum number of replicates')
g = p.add_argument_group('advanced arguments')
g.add_argument(
'--max_time',
help='Maximum training time in hours',
type=float)
g.add_argument(
'--stop_file',
help='File that terminates training if it exists')
g.add_argument(
'--seed',
help='Seed of random number generator',
type=int,
default=0)
g.add_argument(
'--no_log_outputs',
help='Do not log performance metrics of individual outputs',
action='store_true')
g.add_argument(
'--verbose',
help='More detailed log messages',
action='store_true')
g.add_argument(
'--log_file',
help='Write log messages to file')
g.add_argument(
'--data_q_size',
help='Size of data generator queue',
type=int,
default=10)
g.add_argument(
'--data_nb_worker',
help='Number of worker for data generator queue',
type=int,
default=1)
return p
def get_callbacks(self):
opts = self.opts
callbacks = []
if opts.val_files:
callbacks.append(kcbk.EarlyStopping(
'val_loss' if opts.val_files else 'loss',
patience=opts.early_stopping,
verbose=1
))
callbacks.append(kcbk.ModelCheckpoint(
os.path.join(opts.out_dir, 'model_weights_train.h5'),
save_best_only=False))
monitor = 'val_loss' if opts.val_files else 'loss'
callbacks.append(kcbk.ModelCheckpoint(
os.path.join(opts.out_dir, 'model_weights_val.h5'),
monitor=monitor,
save_best_only=True, verbose=1
))
max_time = int(opts.max_time * 3600) if opts.max_time else None
callbacks.append(cbk.TrainingStopper(
max_time=max_time,
stop_file=opts.stop_file,
verbose=1
))
def learning_rate_schedule(epoch):
lr = opts.learning_rate * opts.learning_rate_decay**epoch
print('Learning rate: %.3g' % lr)
return lr
callbacks.append(kcbk.LearningRateScheduler(learning_rate_schedule))
def save_lc(epoch, epoch_logs, val_epoch_logs):
logs = {'lc_train.tsv': epoch_logs,
'lc_val.tsv': val_epoch_logs}
for name, logs in six.iteritems(logs):
if not logs:
continue
logs = pd.DataFrame(logs)
with open(os.path.join(opts.out_dir, name), 'w') as f:
f.write(perf_logs_str(logs))
metrics = OrderedDict()
for metric_funs in six.itervalues(self.metrics):
for metric_fun in metric_funs:
metrics[metric_fun.__name__] = True
metrics = ['loss'] + list(metrics.keys())
self.perf_logger = cbk.PerformanceLogger(
callbacks=[save_lc],
metrics=metrics,
precision=LOG_PRECISION,
verbose=not opts.no_log_outputs
)
callbacks.append(self.perf_logger)
if not opts.no_tensorboard:
callbacks.append(kcbk.TensorBoard(
log_dir=opts.out_dir,
histogram_freq=0,
write_graph=True,
write_images=True
))
return callbacks
def print_output_stats(self, output_stats):
table = OrderedDict()
for name, stats in six.iteritems(output_stats):
table.setdefault('name', []).append(name)
for key in stats:
table.setdefault(key, []).append(stats[key])
print('Output statistics:')
print(format_table(table))
print()
def print_class_weights(self, class_weights):
table = OrderedDict()
for name, class_weight in six.iteritems(class_weights):
if not class_weight:
continue
column = []
for cla, weight in six.iteritems(class_weight):
column.append('%s=%.2f' % (cla, weight))
table[name] = column
if table:
print('Class weights:')
print(format_table(table))
print()
def build_dna_model(self):
opts = self.opts
log = self.log
if os.path.exists(opts.dna_model[0]):
log.info('Loading existing DNA model ...')
dna_model = mod.load_model(opts.dna_model, log=log.info)
remove_outputs(dna_model)
rename_layers(dna_model, 'dna')
else:
log.info('Building DNA model ...')
dna_model_builder = mod.dna.get(opts.dna_model[0])(
l1_decay=opts.l1_decay,
l2_decay=opts.l2_decay,
dropout=opts.dropout)
dna_wlen = dat.get_dna_wlen(opts.train_files[0], opts.dna_wlen)
dna_inputs = dna_model_builder.inputs(dna_wlen)
dna_model = dna_model_builder(dna_inputs)
return dna_model
def build_cpg_model(self):
opts = self.opts
log = self.log
replicate_names = dat.get_replicate_names(
opts.train_files[0],
regex=opts.replicate_names,
nb_key=opts.nb_replicate)
if not replicate_names:
raise ValueError('No replicates found!')
print('Replicate names:')
print(', '.join(replicate_names))
print()
cpg_wlen = dat.get_cpg_wlen(opts.train_files[0], opts.cpg_wlen)
if os.path.exists(opts.cpg_model[0]):
log.info('Loading existing CpG model ...')
src_cpg_model = mod.load_model(opts.cpg_model, log=log.info)
remove_outputs(src_cpg_model)
rename_layers(src_cpg_model, 'cpg')
nb_replicate = src_cpg_model.input_shape[0][1]
if nb_replicate != len(replicate_names):
tmp = 'CpG model was trained with %d replicates but %d'
'replicates provided. Copying weight to new model ...'
tmp %= (nb_replicate, len(replicate_names))
log.info('Replicate names differ: '
'Copying weights to new model ...')
cpg_model_builder = mod.cpg.get(src_cpg_model.name)(
l1_decay=opts.l1_decay,
l2_decay=opts.l2_decay,
dropout=opts.dropout)
cpg_inputs = cpg_model_builder.inputs(cpg_wlen, replicate_names)
cpg_model = cpg_model_builder(cpg_inputs)
mod.copy_weights(src_cpg_model, cpg_model)
else:
cpg_model = src_cpg_model
else:
log.info('Building CpG model ...')
cpg_model_builder = mod.cpg.get(opts.cpg_model[0])(
l1_decay=opts.l1_decay,
l2_decay=opts.l2_decay,
dropout=opts.dropout)
cpg_inputs = cpg_model_builder.inputs(cpg_wlen, replicate_names)
cpg_model = cpg_model_builder(cpg_inputs)
return cpg_model
def build_model(self):
opts = self.opts
log = self.log
output_names = dat.get_output_names(opts.train_files[0],
regex=opts.output_names,
nb_key=opts.nb_output)
if not output_names:
raise ValueError('No outputs found!')
dna_model = None
if opts.dna_model:
dna_model = self.build_dna_model()
cpg_model = None
if opts.cpg_model:
cpg_model = self.build_cpg_model()
if dna_model is not None and cpg_model is not None:
log.info('Joining models ...')
joint_model_builder = mod.joint.get(opts.joint_model)(
l1_decay=opts.l1_decay,
l2_decay=opts.l2_decay,
dropout=opts.dropout)
stem = joint_model_builder([dna_model, cpg_model])
stem.name = '_'.join([stem.name, dna_model.name, cpg_model.name])
elif dna_model is not None:
stem = dna_model
elif cpg_model is not None:
stem = cpg_model
else:
log.info('Loading existing model ...')
stem = mod.load_model(opts.model_files, log=log.info)
if sorted(output_names) == sorted(stem.output_names):
return stem
log.info('Removing existing output layers ...')
remove_outputs(stem)
outputs = mod.add_output_layers(stem.outputs[0], output_names)
model = Model(inputs=stem.inputs, outputs=outputs, name=stem.name)
return model
def set_trainability(self, model):
opts = self.opts
trainable = []
not_trainable = []
if opts.fine_tune:
not_trainable.append('.*')
elif opts.train_models:
not_trainable.append('.*')
for name in opts.train_models:
trainable.append('%s/' % name)
if opts.freeze_filter:
not_trainable.append(mod.get_first_conv_layer(model.layers).name)
if not trainable and opts.trainable:
trainable = opts.trainable
if not not_trainable and opts.not_trainable:
not_trainable = opts.not_trainable
if not trainable and not not_trainable:
return
table = OrderedDict()
table['layer'] = []
table['trainable'] = []
for layer in model.layers:
if is_input_layer(layer) or is_output_layer(layer, model):
continue
if not hasattr(layer, 'trainable'):
continue
for regex in not_trainable:
if re.match(regex, layer.name):
layer.trainable = False
for regex in trainable:
if re.match(regex, layer.name):
layer.trainable = True
table['layer'].append(layer.name)
table['trainable'].append(layer.trainable)
print('Layer trainability:')
print(format_table(table))
print()
def init_filter_weights(self, filename, conv_layer):
h5_file = h5.File(filename[0], 'r')
group = h5_file
if len(filename) > 1:
group = h5_file[filename[1]]
weights = group['weights'].value
bias = None
if 'bias' in group:
bias = group['bias'].value
h5_file.close()
assert weights.ndim == 4
if weights.shape[1] != 1:
weights = weights[:, :, :, 0]
weights = np.swapaxes(weights, 0, 2)
weights = np.expand_dims(weights, 1)
# filter_size x 1 x 4 x nb_filter
cur_weights, cur_bias = conv_layer.get_weights()
# Adapt number of filters
tmp = min(weights.shape[-1], cur_weights.shape[-1])
weights = weights[:, :, :, :tmp]
# Adapt filter size
if len(weights) > len(cur_weights):
# Truncate weights
idx = (len(weights) - len(cur_weights)) // 2
weights = weights[idx:(idx + len(cur_weights))]
elif len(weights) < len(cur_weights):
# Pad weights
shape = [len(cur_weights)] + list(weights.shape[1:])
pad_weights = np.random.uniform(0, 1, shape) * 1e-2
idx = (len(cur_weights) - len(weights)) // 2
pad_weights[idx:(idx + len(weights))] = weights
weights = pad_weights
assert np.all(weights.shape[:-1] == cur_weights.shape[:-1])
cur_weights[:, :, :, :weights.shape[-1]] = weights
if bias is not None:
bias = bias[:len(cur_bias)]
cur_bias[:len(bias)] = bias
conv_layer.set_weights((cur_weights, cur_bias))
print('%d filters initialized' % weights.shape[-1])
def main(self, name, opts):
logging.basicConfig(filename=opts.log_file,
format='%(levelname)s (%(asctime)s): %(message)s')
log = logging.getLogger(name)
if opts.verbose:
log.setLevel(logging.DEBUG)
else:
log.setLevel(logging.INFO)
if opts.seed is not None:
np.random.seed(opts.seed)
random.seed(opts.seed)
self.log = log
self.opts = opts
make_dir(opts.out_dir)
log.info('Building model ...')
model = self.build_model()
model.summary()
self.set_trainability(model)
if opts.filter_weights:
conv_layer = mod.get_first_conv_layer(model.layers)
log.info('Initializing filters of %s ...' % conv_layer.name)
self.init_filter_weights(opts.filter_weights, conv_layer)
mod.save_model(model, os.path.join(opts.out_dir, 'model.json'))
log.info('Computing output statistics ...')
output_names = model.output_names
output_stats = OrderedDict()
if opts.no_class_weights:
class_weights = None
else:
class_weights = OrderedDict()
for name in output_names:
output = hdf.read(opts.train_files, 'outputs/%s' % name,
nb_sample=opts.nb_train_sample)
output = list(output.values())[0]
output_stats[name] = get_output_stats(output)
if class_weights is not None:
class_weights[name] = get_output_class_weights(name, output)
self.print_output_stats(output_stats)
if class_weights:
self.print_class_weights(class_weights)
output_weights = None
if opts.output_weights:
log.info('Initializing output weights ...')
output_weights = get_output_weights(output_names,
opts.output_weights)
print('Output weights:')
for output_name in output_names:
if output_name in output_weights:
print('%s: %.2f' % (output_name,
output_weights[output_name]))
print()
self.metrics = dict()
for output_name in output_names:
self.metrics[output_name] = get_metrics(output_name)
optimizer = Adam(lr=opts.learning_rate)
model.compile(optimizer=optimizer,
loss=mod.get_objectives(output_names),
loss_weights=output_weights,
metrics=self.metrics)
log.info('Loading data ...')
replicate_names = dat.get_replicate_names(
opts.train_files[0],
regex=opts.replicate_names,
nb_key=opts.nb_replicate)
data_reader = mod.data_reader_from_model(
model, replicate_names=replicate_names)
nb_train_sample = dat.get_nb_sample(opts.train_files,
opts.nb_train_sample)
train_data = data_reader(opts.train_files,
class_weights=class_weights,
batch_size=opts.batch_size,
nb_sample=nb_train_sample,
shuffle=True,
loop=True)
if opts.val_files:
nb_val_sample = dat.get_nb_sample(opts.val_files,
opts.nb_val_sample)
val_data = data_reader(opts.val_files,
batch_size=opts.batch_size,
nb_sample=nb_val_sample,
shuffle=False,
loop=True)
else:
val_data = None
nb_val_sample = None
log.info('Initializing callbacks ...')
callbacks = self.get_callbacks()
log.info('Training model ...')
print()
print('Training samples: %d' % nb_train_sample)
if nb_val_sample:
print('Validation samples: %d' % nb_val_sample)
model.fit_generator(
train_data,
steps_per_epoch=nb_train_sample // opts.batch_size,
epochs=opts.nb_epoch,
callbacks=callbacks,
validation_data=val_data,
validation_steps=nb_val_sample // opts.batch_size,
max_queue_size=opts.data_q_size,
workers=opts.data_nb_worker,
verbose=0)
print('\nTraining set performance:')
print(format_table(self.perf_logger.epoch_logs,
precision=LOG_PRECISION))
if self.perf_logger.val_epoch_logs:
print('\nValidation set performance:')
print(format_table(self.perf_logger.val_epoch_logs,
precision=LOG_PRECISION))
# Restore model with highest validation performance
filename = os.path.join(opts.out_dir, 'model_weights_val.h5')
if os.path.isfile(filename):
model.load_weights(filename)
# Delete metrics since they cause problems when loading the model
# from HDF5 file. Metrics can be loaded from json + weights file.
model.metrics = None
model.metrics_names = None
model.metrics_tensors = None
model.save(os.path.join(opts.out_dir, 'model.h5'))
log.info('Done!')
return 0
if __name__ == '__main__':
app = App()
app.run(sys.argv)
| mit |
eickenberg/scikit-learn | examples/linear_model/plot_ols_ridge_variance.py | 387 | 2060 | #!/usr/bin/python
# -*- coding: utf-8 -*-
"""
=========================================================
Ordinary Least Squares and Ridge Regression Variance
=========================================================
Due to the few points in each dimension and the straight
line that linear regression uses to follow these points
as well as it can, noise on the observations will cause
great variance as shown in the first plot. Every line's slope
can vary quite a bit for each prediction due to the noise
induced in the observations.
Ridge regression is basically minimizing a penalised version
of the least-squared function. The penalising `shrinks` the
value of the regression coefficients.
Despite the few data points in each dimension, the slope
of the prediction is much more stable and the variance
in the line itself is greatly reduced, in comparison to that
of the standard linear regression
"""
print(__doc__)
# Code source: Gaël Varoquaux
# Modified for documentation by Jaques Grobler
# License: BSD 3 clause
import numpy as np
import matplotlib.pyplot as plt
from sklearn import linear_model
X_train = np.c_[.5, 1].T
y_train = [.5, 1]
X_test = np.c_[0, 2].T
np.random.seed(0)
classifiers = dict(ols=linear_model.LinearRegression(),
ridge=linear_model.Ridge(alpha=.1))
fignum = 1
for name, clf in classifiers.items():
fig = plt.figure(fignum, figsize=(4, 3))
plt.clf()
plt.title(name)
ax = plt.axes([.12, .12, .8, .8])
for _ in range(6):
this_X = .1 * np.random.normal(size=(2, 1)) + X_train
clf.fit(this_X, y_train)
ax.plot(X_test, clf.predict(X_test), color='.5')
ax.scatter(this_X, y_train, s=3, c='.5', marker='o', zorder=10)
clf.fit(X_train, y_train)
ax.plot(X_test, clf.predict(X_test), linewidth=2, color='blue')
ax.scatter(X_train, y_train, s=30, c='r', marker='+', zorder=10)
ax.set_xticks(())
ax.set_yticks(())
ax.set_ylim((0, 1.6))
ax.set_xlabel('X')
ax.set_ylabel('y')
ax.set_xlim(0, 2)
fignum += 1
plt.show()
| bsd-3-clause |
dkriegner/xrayutilities | examples/simpack_xrr_diffuse.py | 1 | 2087 | # This file is part of xrayutilities.
#
# xrayutilities is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
# Copyright (C) 2018 Dominik Kriegner <[email protected]>
import time
import xrayutilities as xu
from matplotlib.pylab import *
sub = xu.simpack.Layer(xu.materials.Si, inf, roughness=1, lat_correl=100)
lay1 = xu.simpack.Layer(xu.materials.Si, 200, roughness=1, lat_correl=200)
lay2 = xu.simpack.Layer(xu.materials.Ge, 70, roughness=3, lat_correl=50)
ls = xu.simpack.LayerStack('SL 5', sub+5*(lay2+lay1))
alphai = arange(0.17, 2, 0.001)
print("calculate method=1, H=1, vert=0")
start = time.time()
m = xu.simpack.DiffuseReflectivityModel(ls, sample_width=10, beam_width=1,
energy='CuKa1', vert_correl=1000,
vert_nu=0, H=1, method=1, vert_int=0)
d1 = m.simulate(alphai)
print("elapsed time: %.4f" % (time.time() - start))
print("calculate method=2, H=1, vert=0")
start = time.time()
m = xu.simpack.DiffuseReflectivityModel(ls, sample_width=10, beam_width=1,
energy='CuKa1', vert_correl=1000,
vert_nu=0, H=1, method=2, vert_int=0)
d2 = m.simulate(alphai)
print("elapsed time: %.4f" % (time.time() - start))
figure()
semilogy(alphai, d1, label='method=1')
semilogy(alphai, d2, label='method=2')
legend()
xlabel('incidence angle (deg)')
ylabel('intensity (arb. u.)')
tight_layout()
| gpl-2.0 |
UManPychron/pychron | pychron/core/ui/qt/map_editor.py | 2 | 4675 | # ===============================================================================
# Copyright 2019 ross
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===============================================================================
import smopy
from PIL import Image
from pyface.qt.QtGui import QPainter, QFrame, QPixmap, QImage
from traitsui.qt4.basic_editor_factory import BasicEditorFactory
from traitsui.qt4.editor import Editor
class QMapWidget(QFrame):
def __init__(self, *args, **kw):
super(QMapWidget, self).__init__(*args, **kw)
self._pix_maps = []
# self._pix_map = QPixmap(self.width(), self.height())
# self._pix_map.fill(Qt.transparent)
def set_tile(self, image):
data = image.tobytes('raw', 'RGB')
im = QImage(data, image.size[0], image.size[1], QImage.Format_RGB888)
pix = QPixmap.fromImage(im)
self._pix_maps.append(pix)
# print(self._pix_map)
self.update()
#
# def resizeEvent(self, event):
# print('asdf', event.size().width())
# esize = event.size()
# csize = self._pix_map.size()
#
# try:
#
# print(csize.width(), esize.width(), csize.height(), esize.height())
# self._pix_map = self._pix_map.scaled(csize.width()/esize.width(),
# csize.height()/esize.height(),)
# except ZeroDivisionError:
# pass
#
# # self.update()
# self.repaint()
def paintEvent(self, event):
super(QMapWidget, self).paintEvent(event)
qp = QPainter()
qp.begin(self)
for p in self._pix_maps:
qp.drawPixmap(0, 0, p)
qp.end()
# def set_screen(self):
# self._screen = QPixMap()
class _MapEditor(Editor):
def init(self, parent):
self.control = self._create_control(parent)
def update_editor(self):
if self.control:
self.control.update()
# def set_size_policy(self, direction, resizable, springy, stretch):
# pass
def _create_control(self, parent):
control = QMapWidget()
# control.setMaximumSize(200,200)
lat_min = 34.052999
lon_min = -106.924551
lat_max = 34.076752
lon_max = -106.885971
#
# lat_min = 34.052999
# lon_min = -106.81
# lat_max = 34.08
# lon_max = -106.83
rect = (lat_min, lon_min, lat_max, lon_max)
server = 'https://tiles.wmflabs.org/bw-mapnik/{z}/{x}/{y}.png'
server = 'http://c.tile.stamen.com/watercolor/{z}/{x}/{y}.png'
# server = 'https://c.tiles.wmflabs.org/hillshading/{z}/{x}{y}.png'
# server = 'https://mt1.google.com/vt/lyrs=y&x={x}&y={y}&z={z}' # satelite
# server = 'https://mt1.google.com/vt/lyrs=t&x={x}&y={y}&z={z}' # terrain
# server = 'https://mt1.google.com/vt/lyrs=r&x={x}&y={y}&z={z}' # maps
smopy.TILE_SERVER = server
m = smopy.Map(rect, z=10)
# m = smopy.Map(rect)
# m = smopy.Map(lat_min, lon_min, z=10, tileserver='http://c.tile.stamen.com/watercolor/{z}/{x}/{y}.png')
# m.show_ipython()
# control.set_tile(m.img)
base = m.img
base = base.convert('RGBA')
base.putalpha(200)
control.set_tile(base)
# return control
server = 'https://tiles.wmflabs.org/bw-mapnik/{z}/{x}/{y}.png'
# server = 'https://mt1.google.com/vt/lyrs=y&x={x}&y={y}&z={z}' # satelite
smopy.TILE_SERVER = server
m = smopy.Map(rect, z=10)
# img = m.img
# img = img.convert('RGBA')
# img.putalpha(128)
# img = img.convert('RGB')
img = m.img.convert('RGBA')
img.putalpha(128)
img = Image.alpha_composite(base, img)
control.set_tile(img)
# control.set_tile(Image.blend(base, l1, 129))
# m.show_mpl()
# from matplotlib.pyplot import show
# show()
# control.set_screen()
return control
class MapViewEditor(BasicEditorFactory):
klass = _MapEditor
# ============= EOF =============================================
| apache-2.0 |
ebernhardson/l2r | code/task.py | 1 | 9415 | # -*- coding: utf-8 -*-
"""
@author: Chenglong Chen <[email protected]>
@brief: definitions for
- learner & ensemble learner
- feature & stacking feature
- task & stacking task
- task optimizer
"""
import os
import sys
import time
from optparse import OptionParser
from itertools import chain
import numpy as np
import pandas as pd
from scipy.stats import kendalltau
from sklearn.model_selection import GroupKFold
from sklearn.linear_model import Lasso, Ridge, BayesianRidge
from sklearn.ensemble import ExtraTreesRegressor, RandomForestRegressor, GradientBoostingRegressor
from hyperopt import fmin, tpe, hp, STATUS_OK, Trials, space_eval
from rankpy.metrics._metrics import KendallTau
import config
from utils import dist_utils, logging_utils, table_utils, time_utils
from utils.xgb_utils import XGBRank
from utils.rankpy_utils import LambdaMART
try:
from utils.keras_utils import KerasDNNRegressor
except:
pass
from model_param_space import ModelParamSpace
class Learner:
def __init__(self, learner_name, param_dict):
self.learner_name = learner_name
self.param_dict = param_dict
self.learner = self._get_learner()
def __str__(self):
return self.learner_name
def _get_learner(self):
# xgboost
if self.learner_name == "reg_xgb_rank":
return XGBRank(**self.param_dict)
# ranky
if self.learner_name == "reg_rankpy_lambdamart":
return LambdaMART(**self.param_dict)
# TODO: https://sourceforge.net/p/lemur/wiki/RankLib%20How%20to%20use/
# TODO: http://www.cs.cornell.edu/people/tj/svm_light/svm_rank.html
return None
def fit(self, X, y, ids, weight=None, feature_names=None):
if feature_names is not None:
self.learner.fit(X, y, ids, weight, feature_names)
else:
self.learner.fit(X, y, ids, weight)
return self
def predict(self, X, ids, weight=None, feature_names=None):
if feature_names is not None:
y_pred = self.learner.predict(X, ids, weight, feature_names)
else:
y_pred = self.learner.predict(X, ids, weight)
return y_pred
def plot_importance(self):
ax = self.learner.plot_importance()
return ax
class Feature:
def __init__(self, feature_name):
self.feature_name = feature_name
self.data_dict = self._load_data_dict()
def __str__(self):
return self.feature_name
def _load_data_dict(self):
fname = os.path.join(config.FEAT_DIR+"/Combine", self.feature_name+config.FEAT_FILE_SUFFIX)
data_dict = table_utils._read(fname)
return data_dict
## for refit
def _get_train_test_data(self):
# feature
X = self.data_dict["X"]
y = self.data_dict["y"]
w = self.data_dict["weights"]
ids = self.data_dict["query_ids"]
# split into train/test. Leaves out 30% of queries.
# TODO: Use all 3 splits for CV.
splitter = GroupKFold(n_splits=3)
train, test = next(splitter.split(X, None, ids))
# TODO: split in feature_combiner
X_train, X_test, y_train, y_test, ids_train, ids_test, w_train, w_test = chain.from_iterable(
((a[train], a[test]) for a in [X, y, w, ids]))
return X[train], y[train], w[train], ids[train], X[test], y[test], w[test], ids[test]
## for feature importance
def _get_feature_names(self):
return self.data_dict["feature_names"]
class Task:
def __init__(self, learner, feature, suffix, logger, verbose=True, plot_importance=False):
self.learner = learner
self.feature = feature
self.suffix = suffix
self.logger = logger
self.verbose = verbose
self.plot_importance = plot_importance
self.r2 = 0
def __str__(self):
return "[Feat@%s]_[Learner@%s]%s"%(str(self.feature), str(self.learner), str(self.suffix))
def _print_param_dict(self, d, prefix=" ", incr_prefix=" "):
for k,v in sorted(d.items()):
if isinstance(v, dict):
self.logger.info("%s%s:" % (prefix,k))
self._print_param_dict(v, prefix+incr_prefix, incr_prefix)
else:
self.logger.info("%s%s: %s" % (prefix,k,v))
def fit(self):
X_train, y_train, w_train, ids_train, X_test, y_test, w_test, ids_test = self.feature._get_train_test_data()
if self.plot_importance:
feature_names = self.feature._get_feature_names()
self.learner.fit(X_train, y_train, ids_train, w_train, feature_names)
y_pred = self.learner.predict(X_test, ids_test, w_test, feature_names)
else:
self.learner.fit(X_train, y_train, ids_train, w_train)
y_pred = self.learner.predict(X_test, ids_test, w_test)
# Compare y_pred vs y_test
taus = []
# Weighted kendall tau
metric = KendallTau(lambda i: -1 / np.log2(i + 2))
qweight_sum = 0
for i in np.unique(ids_test):
# probably a better way to do this...
condition = ids_test == i
# I think argsort is all we need...
yi_test = np.argsort(y_test[condition])
yi_pred = np.argsort(y_pred[condition])
tau = metric.distance(yi_test, yi_pred)
taus.append(tau)
self.mean_tau = np.mean(taus)
self.std_tau = np.std(taus)
self.logger.info("[%s] Mean Kendalls Tau: %f" % (self.__str__(), self.mean_tau))
self.logger.info("[%s] Std Kendalls Tau: %f" % (self.__str__(), self.std_tau))
# plot importance
if self.plot_importance:
ax = self.learner.plot_importance()
ax.figure.savefig("%s/%s.pdf"%(config.FIG_DIR, self.__str__()))
return self
def go(self):
self.fit()
return self
class TaskOptimizer:
def __init__(self, learner_name, feature_name, logger,
max_evals=100, verbose=True, plot_importance=False):
self.learner_name = learner_name
self.feature_name = feature_name
self.feature = self._get_feature()
self.logger = logger
self.max_evals = max_evals
self.verbose = verbose
self.plot_importance = plot_importance
self.trial_counter = 0
self.model_param_space = ModelParamSpace(self.learner_name)
def _get_feature(self):
return Feature(self.feature_name)
def _obj(self, param_dict):
self.trial_counter += 1
param_dict = self.model_param_space._convert_int_param(param_dict)
learner = Learner(self.learner_name, param_dict)
suffix = "_[Id@%s]"%str(self.trial_counter)
self.task = Task(learner, self.feature, suffix, self.logger, self.verbose, self.plot_importance)
self.task.go()
ret = {
"loss": 1. - self.task.mean_tau,
"attachments": {
"std_tau": self.task.std_tau,
},
"status": STATUS_OK,
}
return ret
def run(self):
start = time.time()
trials = Trials()
best = fmin(self._obj, self.model_param_space._build_space(), tpe.suggest, self.max_evals, trials)
best_params = space_eval(self.model_param_space._build_space(), best)
best_params = self.model_param_space._convert_int_param(best_params)
# To turn this into a loss function these are actually 1 - tau,
# converting back is same
trial_mean_taus = 1 - np.asarray(trials.losses(), dtype=float)
best_ind = np.argmin(trial_mean_taus)
best_mean_tau = trial_mean_taus[best_ind]
self.logger.info("-"*50)
self.logger.info("Best Mean Kendalls Tau: %.6f" % (best_mean_tau))
self.logger.info("Best param")
self.task._print_param_dict(best_params)
end = time.time()
_sec = end - start
_min = int(_sec/60.)
self.logger.info("Time")
if _min > 0:
self.logger.info(" %d mins"%_min)
else:
self.logger.info(" %d secs"%_sec)
self.logger.info("-"*50)
#------------------------ Main -------------------------
def main(options):
logname = "[Feat@%s]_[Learner@%s]_hyperopt_%s.log"%(
options.feature_name, options.learner_name, time_utils._timestamp())
logger = logging_utils._get_logger(config.LOG_DIR, logname)
optimizer = TaskOptimizer(options.learner_name,
options.feature_name, logger, options.max_evals, verbose=True,
plot_importance=options.plot_importance)
optimizer.run()
def parse_args(parser):
parser.add_option("-f", "--feat", type="string", dest="feature_name",
help="feature name", default="basic")
parser.add_option("-l", "--learner", type="string", dest="learner_name",
help="learner name", default="reg_skl_ridge")
parser.add_option("-e", "--eval", type="int", dest="max_evals",
help="maximun number of evals for hyperopt", default=100)
parser.add_option("-p", default=False, action="store_true", dest="plot_importance",
help="plot feautre importance (currently only for xgboost)")
(options, args) = parser.parse_args()
return options, args
if __name__ == "__main__":
parser = OptionParser()
options, args = parse_args(parser)
main(options)
| mit |
jzt5132/scikit-learn | examples/linear_model/plot_ols.py | 220 | 1940 | #!/usr/bin/python
# -*- coding: utf-8 -*-
"""
=========================================================
Linear Regression Example
=========================================================
This example uses the only the first feature of the `diabetes` dataset, in
order to illustrate a two-dimensional plot of this regression technique. The
straight line can be seen in the plot, showing how linear regression attempts
to draw a straight line that will best minimize the residual sum of squares
between the observed responses in the dataset, and the responses predicted by
the linear approximation.
The coefficients, the residual sum of squares and the variance score are also
calculated.
"""
print(__doc__)
# Code source: Jaques Grobler
# License: BSD 3 clause
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model
# Load the diabetes dataset
diabetes = datasets.load_diabetes()
# Use only one feature
diabetes_X = diabetes.data[:, np.newaxis, 2]
# Split the data into training/testing sets
diabetes_X_train = diabetes_X[:-20]
diabetes_X_test = diabetes_X[-20:]
# Split the targets into training/testing sets
diabetes_y_train = diabetes.target[:-20]
diabetes_y_test = diabetes.target[-20:]
# Create linear regression object
regr = linear_model.LinearRegression()
# Train the model using the training sets
regr.fit(diabetes_X_train, diabetes_y_train)
# The coefficients
print('Coefficients: \n', regr.coef_)
# The mean square error
print("Residual sum of squares: %.2f"
% np.mean((regr.predict(diabetes_X_test) - diabetes_y_test) ** 2))
# Explained variance score: 1 is perfect prediction
print('Variance score: %.2f' % regr.score(diabetes_X_test, diabetes_y_test))
# Plot outputs
plt.scatter(diabetes_X_test, diabetes_y_test, color='black')
plt.plot(diabetes_X_test, regr.predict(diabetes_X_test), color='blue',
linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()
| bsd-3-clause |
IniterWorker/epitech-stats-notes | gui/gui.py | 1 | 1264 | import tkinter as tk
import matplotlib
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2TkAgg
from matplotlib.figure import Figure
from config import Configure
matplotlib.use("TkAgg")
class Application(tk.Frame):
def __init__(self, master=None):
super().__init__(master)
self.pack()
self.create_widgets()
self.master.wm_minsize(800, 600)
def create_widgets(self):
self.hi_there = tk.Button(self)
self.hi_there["text"] = "Hello World\n(click me)"
self.hi_there["command"] = self.say_hi
self.hi_there.pack(side="top")
self.quit = tk.Button(self, text="QUIT", fg="red", command=root.destroy)
self.quit.pack(side="bottom")
f = Figure(figsize=(5, 5), dpi=100)
a = f.add_subplot(111)
a.plot([1, 2, 3, 4, 5, 6, 7, 8], [5, 6, 1, 3, 8, 9, 3, 5])
canvas = FigureCanvasTkAgg(f, self)
canvas.show()
canvas.get_tk_widget().pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True)
def say_hi(self):
print("hi there, everyone!")
def run_gui_mode():
root = tk.Tk()
root.geometry("800x600")
window = Application(master=root)
window.master.title("Epitech Stats")
window.mainloop()
| mit |
alexeyum/scikit-learn | examples/ensemble/plot_random_forest_regression_multioutput.py | 28 | 2642 | """
============================================================
Comparing random forests and the multi-output meta estimator
============================================================
An example to compare multi-output regression with random forest and
the :ref:`multioutput.MultiOutputRegressor <_multiclass>` meta-estimator.
This example illustrates the use of the
:ref:`multioutput.MultiOutputRegressor <_multiclass>` meta-estimator
to perform multi-output regression. A random forest regressor is used,
which supports multi-output regression natively, so the results can be
compared.
The random forest regressor will only ever predict values within the
range of observations or closer to zero for each of the targets. As a
result the predictions are biased towards the centre of the circle.
Using a single underlying feature the model learns both the
x and y coordinate as output.
"""
print(__doc__)
# Author: Tim Head <[email protected]>
#
# License: BSD 3 clause
import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split
from sklearn.multioutput import MultiOutputRegressor
# Create a random dataset
rng = np.random.RandomState(1)
X = np.sort(200 * rng.rand(600, 1) - 100, axis=0)
y = np.array([np.pi * np.sin(X).ravel(), np.pi * np.cos(X).ravel()]).T
y += (0.5 - rng.rand(*y.shape))
X_train, X_test, y_train, y_test = train_test_split(X, y,
train_size=400,
random_state=4)
max_depth = 30
regr_multirf = MultiOutputRegressor(RandomForestRegressor(max_depth=max_depth,
random_state=0))
regr_multirf.fit(X_train, y_train)
regr_rf = RandomForestRegressor(max_depth=max_depth, random_state=2)
regr_rf.fit(X_train, y_train)
# Predict on new data
y_multirf = regr_multirf.predict(X_test)
y_rf = regr_rf.predict(X_test)
# Plot the results
plt.figure()
s = 50
a = 0.4
plt.scatter(y_test[:, 0], y_test[:, 1],
c="navy", s=s, marker="s", alpha=a, label="Data")
plt.scatter(y_multirf[:, 0], y_multirf[:, 1],
c="cornflowerblue", s=s, alpha=a,
label="Multi RF score=%.2f" % regr_multirf.score(X_test, y_test))
plt.scatter(y_rf[:, 0], y_rf[:, 1],
c="c", s=s, marker="^", alpha=a,
label="RF score=%.2f" % regr_rf.score(X_test, y_test))
plt.xlim([-6, 6])
plt.ylim([-6, 6])
plt.xlabel("target 1")
plt.ylabel("target 2")
plt.title("Comparing random forests and the multi-output meta estimator")
plt.legend()
plt.show()
| bsd-3-clause |
Nyker510/scikit-learn | sklearn/datasets/twenty_newsgroups.py | 72 | 13586 | """Caching loader for the 20 newsgroups text classification dataset
The description of the dataset is available on the official website at:
http://people.csail.mit.edu/jrennie/20Newsgroups/
Quoting the introduction:
The 20 Newsgroups data set is a collection of approximately 20,000
newsgroup documents, partitioned (nearly) evenly across 20 different
newsgroups. To the best of my knowledge, it was originally collected
by Ken Lang, probably for his Newsweeder: Learning to filter netnews
paper, though he does not explicitly mention this collection. The 20
newsgroups collection has become a popular data set for experiments
in text applications of machine learning techniques, such as text
classification and text clustering.
This dataset loader will download the recommended "by date" variant of the
dataset and which features a point in time split between the train and
test sets. The compressed dataset size is around 14 Mb compressed. Once
uncompressed the train set is 52 MB and the test set is 34 MB.
The data is downloaded, extracted and cached in the '~/scikit_learn_data'
folder.
The `fetch_20newsgroups` function will not vectorize the data into numpy
arrays but the dataset lists the filenames of the posts and their categories
as target labels.
The `fetch_20newsgroups_tfidf` function will in addition do a simple tf-idf
vectorization step.
"""
# Copyright (c) 2011 Olivier Grisel <[email protected]>
# License: BSD 3 clause
import os
import logging
import tarfile
import pickle
import shutil
import re
import codecs
import numpy as np
import scipy.sparse as sp
from .base import get_data_home
from .base import Bunch
from .base import load_files
from ..utils import check_random_state
from ..feature_extraction.text import CountVectorizer
from ..preprocessing import normalize
from ..externals import joblib, six
if six.PY3:
from urllib.request import urlopen
else:
from urllib2 import urlopen
logger = logging.getLogger(__name__)
URL = ("http://people.csail.mit.edu/jrennie/"
"20Newsgroups/20news-bydate.tar.gz")
ARCHIVE_NAME = "20news-bydate.tar.gz"
CACHE_NAME = "20news-bydate.pkz"
TRAIN_FOLDER = "20news-bydate-train"
TEST_FOLDER = "20news-bydate-test"
def download_20newsgroups(target_dir, cache_path):
"""Download the 20 newsgroups data and stored it as a zipped pickle."""
archive_path = os.path.join(target_dir, ARCHIVE_NAME)
train_path = os.path.join(target_dir, TRAIN_FOLDER)
test_path = os.path.join(target_dir, TEST_FOLDER)
if not os.path.exists(target_dir):
os.makedirs(target_dir)
if os.path.exists(archive_path):
# Download is not complete as the .tar.gz file is removed after
# download.
logger.warning("Download was incomplete, downloading again.")
os.remove(archive_path)
logger.warning("Downloading dataset from %s (14 MB)", URL)
opener = urlopen(URL)
with open(archive_path, 'wb') as f:
f.write(opener.read())
logger.info("Decompressing %s", archive_path)
tarfile.open(archive_path, "r:gz").extractall(path=target_dir)
os.remove(archive_path)
# Store a zipped pickle
cache = dict(train=load_files(train_path, encoding='latin1'),
test=load_files(test_path, encoding='latin1'))
compressed_content = codecs.encode(pickle.dumps(cache), 'zlib_codec')
with open(cache_path, 'wb') as f:
f.write(compressed_content)
shutil.rmtree(target_dir)
return cache
def strip_newsgroup_header(text):
"""
Given text in "news" format, strip the headers, by removing everything
before the first blank line.
"""
_before, _blankline, after = text.partition('\n\n')
return after
_QUOTE_RE = re.compile(r'(writes in|writes:|wrote:|says:|said:'
r'|^In article|^Quoted from|^\||^>)')
def strip_newsgroup_quoting(text):
"""
Given text in "news" format, strip lines beginning with the quote
characters > or |, plus lines that often introduce a quoted section
(for example, because they contain the string 'writes:'.)
"""
good_lines = [line for line in text.split('\n')
if not _QUOTE_RE.search(line)]
return '\n'.join(good_lines)
def strip_newsgroup_footer(text):
"""
Given text in "news" format, attempt to remove a signature block.
As a rough heuristic, we assume that signatures are set apart by either
a blank line or a line made of hyphens, and that it is the last such line
in the file (disregarding blank lines at the end).
"""
lines = text.strip().split('\n')
for line_num in range(len(lines) - 1, -1, -1):
line = lines[line_num]
if line.strip().strip('-') == '':
break
if line_num > 0:
return '\n'.join(lines[:line_num])
else:
return text
def fetch_20newsgroups(data_home=None, subset='train', categories=None,
shuffle=True, random_state=42,
remove=(),
download_if_missing=True):
"""Load the filenames and data from the 20 newsgroups dataset.
Read more in the :ref:`User Guide <20newsgroups>`.
Parameters
----------
subset: 'train' or 'test', 'all', optional
Select the dataset to load: 'train' for the training set, 'test'
for the test set, 'all' for both, with shuffled ordering.
data_home: optional, default: None
Specify a download and cache folder for the datasets. If None,
all scikit-learn data is stored in '~/scikit_learn_data' subfolders.
categories: None or collection of string or unicode
If None (default), load all the categories.
If not None, list of category names to load (other categories
ignored).
shuffle: bool, optional
Whether or not to shuffle the data: might be important for models that
make the assumption that the samples are independent and identically
distributed (i.i.d.), such as stochastic gradient descent.
random_state: numpy random number generator or seed integer
Used to shuffle the dataset.
download_if_missing: optional, True by default
If False, raise an IOError if the data is not locally available
instead of trying to download the data from the source site.
remove: tuple
May contain any subset of ('headers', 'footers', 'quotes'). Each of
these are kinds of text that will be detected and removed from the
newsgroup posts, preventing classifiers from overfitting on
metadata.
'headers' removes newsgroup headers, 'footers' removes blocks at the
ends of posts that look like signatures, and 'quotes' removes lines
that appear to be quoting another post.
'headers' follows an exact standard; the other filters are not always
correct.
"""
data_home = get_data_home(data_home=data_home)
cache_path = os.path.join(data_home, CACHE_NAME)
twenty_home = os.path.join(data_home, "20news_home")
cache = None
if os.path.exists(cache_path):
try:
with open(cache_path, 'rb') as f:
compressed_content = f.read()
uncompressed_content = codecs.decode(
compressed_content, 'zlib_codec')
cache = pickle.loads(uncompressed_content)
except Exception as e:
print(80 * '_')
print('Cache loading failed')
print(80 * '_')
print(e)
if cache is None:
if download_if_missing:
cache = download_20newsgroups(target_dir=twenty_home,
cache_path=cache_path)
else:
raise IOError('20Newsgroups dataset not found')
if subset in ('train', 'test'):
data = cache[subset]
elif subset == 'all':
data_lst = list()
target = list()
filenames = list()
for subset in ('train', 'test'):
data = cache[subset]
data_lst.extend(data.data)
target.extend(data.target)
filenames.extend(data.filenames)
data.data = data_lst
data.target = np.array(target)
data.filenames = np.array(filenames)
else:
raise ValueError(
"subset can only be 'train', 'test' or 'all', got '%s'" % subset)
data.description = 'the 20 newsgroups by date dataset'
if 'headers' in remove:
data.data = [strip_newsgroup_header(text) for text in data.data]
if 'footers' in remove:
data.data = [strip_newsgroup_footer(text) for text in data.data]
if 'quotes' in remove:
data.data = [strip_newsgroup_quoting(text) for text in data.data]
if categories is not None:
labels = [(data.target_names.index(cat), cat) for cat in categories]
# Sort the categories to have the ordering of the labels
labels.sort()
labels, categories = zip(*labels)
mask = np.in1d(data.target, labels)
data.filenames = data.filenames[mask]
data.target = data.target[mask]
# searchsorted to have continuous labels
data.target = np.searchsorted(labels, data.target)
data.target_names = list(categories)
# Use an object array to shuffle: avoids memory copy
data_lst = np.array(data.data, dtype=object)
data_lst = data_lst[mask]
data.data = data_lst.tolist()
if shuffle:
random_state = check_random_state(random_state)
indices = np.arange(data.target.shape[0])
random_state.shuffle(indices)
data.filenames = data.filenames[indices]
data.target = data.target[indices]
# Use an object array to shuffle: avoids memory copy
data_lst = np.array(data.data, dtype=object)
data_lst = data_lst[indices]
data.data = data_lst.tolist()
return data
def fetch_20newsgroups_vectorized(subset="train", remove=(), data_home=None):
"""Load the 20 newsgroups dataset and transform it into tf-idf vectors.
This is a convenience function; the tf-idf transformation is done using the
default settings for `sklearn.feature_extraction.text.Vectorizer`. For more
advanced usage (stopword filtering, n-gram extraction, etc.), combine
fetch_20newsgroups with a custom `Vectorizer` or `CountVectorizer`.
Read more in the :ref:`User Guide <20newsgroups>`.
Parameters
----------
subset: 'train' or 'test', 'all', optional
Select the dataset to load: 'train' for the training set, 'test'
for the test set, 'all' for both, with shuffled ordering.
data_home: optional, default: None
Specify an download and cache folder for the datasets. If None,
all scikit-learn data is stored in '~/scikit_learn_data' subfolders.
remove: tuple
May contain any subset of ('headers', 'footers', 'quotes'). Each of
these are kinds of text that will be detected and removed from the
newsgroup posts, preventing classifiers from overfitting on
metadata.
'headers' removes newsgroup headers, 'footers' removes blocks at the
ends of posts that look like signatures, and 'quotes' removes lines
that appear to be quoting another post.
Returns
-------
bunch : Bunch object
bunch.data: sparse matrix, shape [n_samples, n_features]
bunch.target: array, shape [n_samples]
bunch.target_names: list, length [n_classes]
"""
data_home = get_data_home(data_home=data_home)
filebase = '20newsgroup_vectorized'
if remove:
filebase += 'remove-' + ('-'.join(remove))
target_file = os.path.join(data_home, filebase + ".pk")
# we shuffle but use a fixed seed for the memoization
data_train = fetch_20newsgroups(data_home=data_home,
subset='train',
categories=None,
shuffle=True,
random_state=12,
remove=remove)
data_test = fetch_20newsgroups(data_home=data_home,
subset='test',
categories=None,
shuffle=True,
random_state=12,
remove=remove)
if os.path.exists(target_file):
X_train, X_test = joblib.load(target_file)
else:
vectorizer = CountVectorizer(dtype=np.int16)
X_train = vectorizer.fit_transform(data_train.data).tocsr()
X_test = vectorizer.transform(data_test.data).tocsr()
joblib.dump((X_train, X_test), target_file, compress=9)
# the data is stored as int16 for compactness
# but normalize needs floats
X_train = X_train.astype(np.float64)
X_test = X_test.astype(np.float64)
normalize(X_train, copy=False)
normalize(X_test, copy=False)
target_names = data_train.target_names
if subset == "train":
data = X_train
target = data_train.target
elif subset == "test":
data = X_test
target = data_test.target
elif subset == "all":
data = sp.vstack((X_train, X_test)).tocsr()
target = np.concatenate((data_train.target, data_test.target))
else:
raise ValueError("%r is not a valid subset: should be one of "
"['train', 'test', 'all']" % subset)
return Bunch(data=data, target=target, target_names=target_names)
| bsd-3-clause |
RexFuzzle/sfepy | script/gen_gallery.py | 1 | 20332 | #!/usr/bin/env python
"""
Generate the images and rst files for gallery of SfePy examples.
The following steps need to be made to regenerate the documentation with the
updated example files:
1. Generate the files:
- for sfepy.org deployment::
$ ./script/gen_gallery.py -l ../doc-devel
- for local test build run from ./::
$ ./script/gen_gallery.py -l doc/_build/html/
2. remove doc/examples/::
$ rm -rf doc/examples/
3. copy gallery/examples/ to doc/::
$ cp -a gallery/examples/ doc/
4. regenerate the documentation::
$ python setup.py htmldocs
Additional steps for sfepy.org deployment:
- copy doc/_build/html/ to <sfepy.org>/doc-devel/
- copy gallery/gallery.html and gallery/images/ to <sfepy.org>/
"""
import sys
sys.path.append( '.' )
import os
import tempfile
import glob
import re
from optparse import OptionParser
import matplotlib.image as image
import sfepy
from sfepy.base.base import (get_default, ordered_iteritems,
import_file, output, Struct)
from sfepy.base.ioutils import (ensure_path, locate_files, remove_files,
edit_filename)
from sfepy.postprocess.domain_specific import DomainSpecificPlot
omits = [
'vibro_acoustic3d_mid.py',
'linear_elastic_mM.py',
'time_poisson_explicit.py',
'its2D_5.py',
'linear_elastic_probes.py',
'__init__.py',
]
omit_dirs = [
re.compile('.*output.*/').match,
]
custom = {
'acoustics/acoustics3d.py' : {
'_p_1' : {
'view' : (44, 57, 0.24, [-0.004, -0.007, 0.09]),
'roll' : 0,
},
'_p_2' : {
'view' : (-99, 120, 0.4, [0.0, 0.0, 0.07]),
'roll' : 141,
},
},
'acoustics/vibro_acoustic3d.py' : {
'_p1' : {
'view' : (45.0, 54.7, 1.47, [0.0, 0.0, 0.05]),
'roll' : -120,
},
'_p2' : {
'view' : (45.0, 54.7, 1.47, [0.0, 0.0, 0.15]),
'roll' : -120,
},
'_w' : {
'view' : (0.0, 0.0, 0.86, [0.0, 0.0, 0.1]),
'roll' : 0,
},
'_g0' : {
'view' : (0.0, 0.0, 0.86, [0.0, 0.0, 0.1]),
'roll' : 0,
},
},
'diffusion/laplace_1d.py' : {
'' : {
'is_wireframe' : True,
'domain_specific' : {
't' : DomainSpecificPlot('plot_warp_scalar',
['rel_scaling=1']),
},
'view' : (-90, 90, 1.5, [0, 0, 0]),
'roll' : 0,
'opacity' : {'wireframe' : 0.3},
},
},
'diffusion/laplace_coupling_lcbcs.py' : {
'' : {
'is_wireframe' : True,
'domain_specific' : {
'u1' : DomainSpecificPlot('plot_warp_scalar',
['rel_scaling=1']),
'u2' : DomainSpecificPlot('plot_warp_scalar',
['rel_scaling=1']),
},
'view' : (-82, 50, 3.6, [-0.43, -0.55, 0.4]),
'roll' : -23,
'opacity' : {'wireframe' : 0.3},
},
},
'diffusion/poisson_iga.py' : {
'' : {
'is_wireframe' : True,
'domain_specific' : {
't' : DomainSpecificPlot('plot_warp_scalar',
['rel_scaling=1']),
},
'view' : (55, 39, 6.6, [-0.35, -0.29, 0.35]),
'roll' : 15,
'opacity' : {'wireframe' : 0.3},
},
},
'diffusion/sinbc.py' : {
'_t' : {
'is_wireframe' : True,
'domain_specific' : {
't' : DomainSpecificPlot('plot_warp_scalar',
['rel_scaling=1']),
},
'view' : (-170, 30, 4.7, [0.34, 0.23, -0.26]),
'roll' : 71,
'opacity' : {'wireframe' : 0.3},
},
'_grad' : {
'opacity' : {'surface' : 0.3},
'view' : (-170, 30, 4.7, [0.34, 0.23, -0.26]),
'roll' : 71,
},
},
'linear_elasticity/elastic_contact_planes.py' : {
'' : {
'is_wireframe' : True,
'domain_specific' : {
'u' : DomainSpecificPlot('plot_displacements',
['rel_scaling=1']),
},
'view' : (-82, 47, 3.4, [-0.5, -0.24, -0.2]),
'roll' : -8.4,
'opacity' : {'wireframe' : 0.3},
},
},
'linear_elasticity/elastic_contact_sphere.py' : {
'' : {
'is_wireframe' : True,
'domain_specific' : {
'u' : DomainSpecificPlot('plot_displacements',
['rel_scaling=1']),
},
'view' : (-82, 47, 3.4, [-0.5, -0.24, -0.2]),
'roll' : -8.4,
'opacity' : {'wireframe' : 0.3},
},
},
'linear_elasticity/elastic_shifted_periodic.py' : {
'' : {
'is_wireframe' : True,
'only_names' : ['u'],
'domain_specific' : {
'u' : DomainSpecificPlot('plot_displacements',
['rel_scaling=1',
'color_kind="scalars"',
'color_name="von_mises_stress"']),
},
'view' : (142, 39, 16, [-4.7, -2.1, -1.9]),
'roll' : 8.4,
'opacity' : {'wireframe' : 0.3},
},
},
'linear_elasticity/linear_elastic_iga.py' : {
'' : {
'is_wireframe' : True,
'domain_specific' : {
'u' : DomainSpecificPlot('plot_displacements',
['rel_scaling=1']),
},
'view' : (-37, 51, 1.5, [-0.28, -0.29, 0.0]),
'roll' : -51.5,
'opacity' : {'wireframe' : 0.2},
},
},
'navier_stokes/stokes_slip_bc.py' : {
'' : {
'view' : (-63, 52, 5.2, [-1.5, -0.65, 0.12]),
'roll' : -32,
'resolution' : (800, 600),
'layout' : 'col',
'rel_scaling' : 0.1,
},
},
'multi_physics/thermo_elasticity_ess.py' : {
'' : {
'is_wireframe' : True,
'only_names' : ['u'],
'domain_specific' : {
'u' : DomainSpecificPlot('plot_displacements',
['rel_scaling=1000',
'color_kind="scalars"',
'color_name="T"']),
},
'view' : (-51, 71, 12.9, [-2.3, -2.4, -0.2]),
'roll' : -65,
'opacity' : {'wireframe' : 0.3},
},
}
}
def _omit(filename):
omit = False
base = os.path.basename(filename)
if base in omits:
omit = True
for omit_dir in omit_dirs:
if omit_dir(filename) is not None:
omit = True
break
return omit
def _get_fig_filenames(ebase, images_dir):
fig_base = os.path.splitext(ebase)[0].replace(os.path.sep, '-')
yield fig_base
if ebase in custom:
suffixes = sorted(custom[ebase].keys())
for suffix in suffixes:
fig_filename = os.path.join(images_dir, fig_base + suffix + '.png')
yield fig_filename
else:
fig_filename = os.path.join(images_dir, fig_base + '.png')
yield fig_filename
def _get_fig_filename(ebase, images_dir, suffix):
fig_base = os.path.splitext(ebase)[0].replace(os.path.sep, '-')
fig_filename = os.path.join(images_dir, fig_base + suffix + '.png')
return fig_filename
def _make_sphinx_path(path, relative=False):
if relative:
aux = path.replace(sfepy.data_dir, '')
prefix = ('..' + os.path.sep) * aux.count(os.path.sep)
sphinx_path = prefix[:-1] + aux
else:
sphinx_path = path.replace(sfepy.data_dir, '/..')
return sphinx_path
def generate_images(images_dir, examples_dir):
"""
Generate images from results of running examples found in
`examples_dir` directory.
The generated images are stored to `images_dir`,
"""
from sfepy.applications import solve_pde
from sfepy.postprocess.viewer import Viewer
from sfepy.postprocess.utils import mlab
prefix = output.prefix
output_dir = tempfile.mkdtemp()
trunk = os.path.join(output_dir, 'result')
options = Struct(output_filename_trunk=trunk,
output_format='vtk',
save_ebc=False,
save_ebc_nodes=False,
save_regions=False,
save_field_meshes=False,
save_regions_as_groups=False,
solve_not=False)
default_views = {'' : {}}
ensure_path(images_dir + os.path.sep)
view = Viewer('', offscreen=False)
for ex_filename in locate_files('*.py', examples_dir):
if _omit(ex_filename): continue
output.level = 0
output.prefix = prefix
ebase = ex_filename.replace(examples_dir, '')[1:]
output('trying "%s"...' % ebase)
try:
problem, state = solve_pde(ex_filename, options=options)
except KeyboardInterrupt:
raise
except:
problem = None
output('***** failed! *****')
if problem is not None:
if ebase in custom:
views = custom[ebase]
else:
views = default_views
tsolver = problem.get_time_solver()
if tsolver.ts is None:
suffix = None
else:
suffix = tsolver.ts.suffix % (tsolver.ts.n_step - 1)
filename = problem.get_output_name(suffix=suffix)
for suffix, kwargs in views.iteritems():
fig_filename = _get_fig_filename(ebase, images_dir, suffix)
fname = edit_filename(filename, suffix=suffix)
output('displaying results from "%s"' % fname)
disp_name = fig_filename.replace(sfepy.data_dir, '')
output('to "%s"...' % disp_name.lstrip(os.path.sep))
view.filename = fname
view(scene=view.scene, show=False, is_scalar_bar=True, **kwargs)
view.save_image(fig_filename)
mlab.clf()
output('...done')
remove_files(output_dir)
output('...done')
def generate_thumbnails(thumbnails_dir, images_dir, scale=0.3):
"""
Generate thumbnails into `thumbnails_dir` corresponding to images in
`images_dir`.
"""
ensure_path(thumbnails_dir + os.path.sep)
output('generating thumbnails...')
filenames = glob.glob(os.path.join(images_dir, '*.png'))
for fig_filename in filenames:
ebase = fig_filename.replace(sfepy.data_dir, '').lstrip(os.path.sep)
output('"%s"' % ebase)
base = os.path.basename(fig_filename)
thumb_filename = os.path.join(thumbnails_dir, base)
image.thumbnail(fig_filename, thumb_filename, scale=scale)
output('...done')
_index = """\
.. _%s-gallery-examples-index:
%s
%s
.. toctree::
:maxdepth: 2
"""
_image = '.. image:: %s'
_include = """\
.. _%s:
%s
%s
**Description**
%s
%s
:download:`source code <%s>`
.. literalinclude:: %s
"""
def generate_rst_files(rst_dir, examples_dir, images_dir):
"""
Generate Sphinx rst files for examples in `examples_dir` with images
in `images_dir` and put them into `rst_dir`.
Returns
-------
dir_map : dict
The directory mapping of examples and corresponding rst files.
"""
ensure_path(rst_dir + os.path.sep)
output('generating rst files...')
dir_map = {}
for ex_filename in locate_files('*.py', examples_dir):
if _omit(ex_filename): continue
ebase = ex_filename.replace(examples_dir, '')[1:]
base_dir = os.path.dirname(ebase)
rst_filename = os.path.basename(ex_filename).replace('.py', '.rst')
dir_map.setdefault(base_dir, []).append((ex_filename, rst_filename))
for dirname, filenames in dir_map.iteritems():
filenames = sorted(filenames, cmp=lambda a, b: cmp(a[1], b[1]))
dir_map[dirname ] = filenames
# Main index.
mfd = open(os.path.join(rst_dir, 'index.rst'), 'w')
mfd.write(_index % ('sfepy', 'Examples', '=' * 8))
for dirname, filenames in ordered_iteritems(dir_map):
full_dirname = os.path.join(rst_dir, dirname)
ensure_path(full_dirname + os.path.sep)
# Subdirectory index.
ifd = open(os.path.join(full_dirname, 'index.rst'), 'w')
ifd.write(_index % (dirname, dirname, '=' * len(dirname)))
for ex_filename, rst_filename in filenames:
full_rst_filename = os.path.join(full_dirname, rst_filename)
output('"%s"' % full_rst_filename.replace(rst_dir, '')[1:])
rst_filename_ns = rst_filename.replace('.rst', '')
ebase = ex_filename.replace(examples_dir, '')[1:]
rst_ex_filename = _make_sphinx_path(ex_filename)
docstring = get_default(import_file(ex_filename).__doc__,
'missing description!')
ifd.write(' %s\n' % rst_filename_ns)
fig_include = ''
fig_base = _get_fig_filenames(ebase, images_dir).next()
for fig_filename in _get_fig_filenames(ebase, images_dir):
rst_fig_filename = _make_sphinx_path(fig_filename)
if os.path.exists(fig_filename):
fig_include += _image % rst_fig_filename + '\n'
# Example rst file.
fd = open(full_rst_filename, 'w')
fd.write(_include % (fig_base, ebase, '=' * len(ebase),
docstring,
fig_include,
rst_ex_filename, rst_ex_filename))
fd.close()
ifd.close()
mfd.write(' %s/index\n' % dirname)
mfd.close()
output('...done')
return dir_map
_gallery_template_file = os.path.join(sfepy.top_dir,
'doc/gallery_template.html')
_link_template = """\
<div class="figure">
<a class="reference external image-reference" href="../%s">
<img alt="%s" src="%s" />
</a>
<p class="caption">
<a class="reference internal" href="../%s"><em>%s</em></a>
</p>
</div>
<div class="toctree-wrapper compound">
</div>
"""
_side_links="<li><a class='reference internal' href='#%s'>%s</a></li>"
_div_line ="""\
<div class="section" id="%s">
<h2>%s<a class="headerlink" href="\#%s" title="Permalink to this headline">
</a></h2>
%s
<div style="clear: both"></div></div>
"""
def generate_gallery_html(examples_dir, output_filename, gallery_dir,
rst_dir, thumbnails_dir, dir_map, link_prefix):
"""
Generate the gallery html file with thumbnail images and links to
examples.
Parameters
----------
output_filename : str
The output html file name.
gallery_dir : str
The top level directory of gallery files.
rst_dir : str
The full path to rst files of examples within `gallery_dir`.
thumbnails_dir : str
The full path to thumbnail images within `gallery_dir`.
dir_map : dict
The directory mapping returned by `generate_rst_files()`
link_prefix : str, optional
The prefix to prepend to links to individual pages of examples.
"""
output('generating %s...' % output_filename)
with open(_gallery_template_file, 'r') as fd:
gallery_template = fd.read()
div_lines=[]
sidebar = []
for dirname, filenames in ordered_iteritems(dir_map):
full_dirname = os.path.join(rst_dir, dirname)
dirnamenew = dirname.replace("_"," ")
sidebarline = _side_links % (dirname, dirnamenew.title())
lines = []
for ex_filename, rst_filename in filenames:
full_rst_filename = os.path.join(full_dirname, rst_filename)
ebase = full_rst_filename.replace(rst_dir, '')[1:]
ebase = edit_filename(ebase, new_ext='.py')
link_base = full_rst_filename.replace(gallery_dir, '')[1:]
link = os.path.join(link_prefix,
os.path.splitext(link_base)[0] + '.html')
_get_fig_filenames(ebase, thumbnails_dir).next()
for thumbnail_filename in _get_fig_filenames(ebase,
thumbnails_dir):
if not os.path.isfile(thumbnail_filename):
# Skip examples with no image (= failed examples).
continue
thumbnail_name = thumbnail_filename.replace(gallery_dir,
'')[1:]
path_to_file = os.path.join(examples_dir,ebase)
docstring = get_default(import_file(path_to_file).__doc__,
'missing description!')
docstring = docstring.replace('e.g.', 'eg:')
docstring = docstring.split('.')
line = _link_template % (link,os.path.splitext(ebase)[0],
thumbnail_name,link,docstring[0]+'.')
lines.append(line)
if(len(lines)!=0):
div_lines.append(_div_line % (dirname, dirnamenew.title(),
dirname, '\n'.join(lines)))
sidebar.append(sidebarline)
fd = open(output_filename, 'w')
fd.write(gallery_template % ((link_prefix,) * 7
+ ('\n'.join(sidebar), '\n'.join(div_lines))))
fd.close()
output('...done')
usage = '%prog [options]\n' + __doc__.rstrip()
help = {
'examples_dir' :
'directory containing examples [default: %default]',
'images_dir' :
'directory where to store gallery images [default: gallery/images]',
'no_images' :
'do not (re)generate images and thumbnails',
'output_filename' :
'output file name [default: %default]',
'link_prefix' :
'prefix to be prepended to links to examples pages in gallery '
'[default: %default]',
}
def main():
parser = OptionParser(usage=usage, version='%prog')
parser.add_option('-e', '--examples-dir', metavar='directory',
action='store', dest='examples_dir',
default='examples', help=help['examples_dir'])
parser.add_option('-i', '--images-dir', metavar='directory',
action='store', dest='images_dir',
default=None, help=help['images_dir'])
parser.add_option('-n', '--no-images',
action='store_true', dest='no_images',
default=False, help=help['no_images'])
parser.add_option('-o', '--output', metavar='output_filename',
action='store', dest='output_filename',
default='gallery/gallery.html',
help=help['output_filename'])
parser.add_option('-l', '--link-prefix', metavar='prefix',
action='store', dest='link_prefix',
default='http://sfepy.org/doc-devel',
help=help['link_prefix'])
(options, args) = parser.parse_args()
examples_dir = os.path.realpath(options.examples_dir)
output_filename = os.path.realpath(options.output_filename)
gallery_dir = os.path.dirname(output_filename)
images_dir = get_default(options.images_dir,
os.path.join(gallery_dir, 'images'))
thumbnails_dir = os.path.join(images_dir, 'thumbnails')
rst_dir = os.path.join(gallery_dir, 'examples')
if not options.no_images:
generate_images(images_dir, examples_dir)
generate_thumbnails(thumbnails_dir, images_dir)
dir_map = generate_rst_files(rst_dir, examples_dir, images_dir)
generate_gallery_html(examples_dir,output_filename, gallery_dir,
rst_dir, thumbnails_dir, dir_map,
link_prefix=options.link_prefix)
if __name__ == '__main__':
main()
| bsd-3-clause |
wesm/arrow | python/pyarrow/tests/test_orc.py | 1 | 6160 | # Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
import decimal
import datetime
import pyarrow as pa
# Marks all of the tests in this module
# Ignore these with pytest ... -m 'not orc'
pytestmark = pytest.mark.orc
try:
from pandas.testing import assert_frame_equal
import pandas as pd
except ImportError:
pass
@pytest.fixture(scope="module")
def datadir(base_datadir):
return base_datadir / "orc"
def fix_example_values(actual_cols, expected_cols):
"""
Fix type of expected values (as read from JSON) according to
actual ORC datatype.
"""
for name in expected_cols:
expected = expected_cols[name]
actual = actual_cols[name]
if (name == "map" and
[d.keys() == {'key', 'value'} for m in expected for d in m]):
# convert [{'key': k, 'value': v}, ...] to [(k, v), ...]
for i, m in enumerate(expected):
expected_cols[name][i] = [(d['key'], d['value']) for d in m]
continue
typ = actual[0].__class__
if issubclass(typ, datetime.datetime):
# timestamp fields are represented as strings in JSON files
expected = pd.to_datetime(expected)
elif issubclass(typ, datetime.date):
# date fields are represented as strings in JSON files
expected = expected.dt.date
elif typ is decimal.Decimal:
converted_decimals = [None] * len(expected)
# decimal fields are represented as reals in JSON files
for i, (d, v) in enumerate(zip(actual, expected)):
if not pd.isnull(v):
exp = d.as_tuple().exponent
factor = 10 ** -exp
converted_decimals[i] = (
decimal.Decimal(round(v * factor)).scaleb(exp))
expected = pd.Series(converted_decimals)
expected_cols[name] = expected
def check_example_values(orc_df, expected_df, start=None, stop=None):
if start is not None or stop is not None:
expected_df = expected_df[start:stop].reset_index(drop=True)
assert_frame_equal(orc_df, expected_df, check_dtype=False)
def check_example_file(orc_path, expected_df, need_fix=False):
"""
Check a ORC file against the expected columns dictionary.
"""
from pyarrow import orc
orc_file = orc.ORCFile(orc_path)
# Exercise ORCFile.read()
table = orc_file.read()
assert isinstance(table, pa.Table)
table.validate()
# This workaround needed because of ARROW-3080
orc_df = pd.DataFrame(table.to_pydict())
assert set(expected_df.columns) == set(orc_df.columns)
# reorder columns if necessary
if not orc_df.columns.equals(expected_df.columns):
expected_df = expected_df.reindex(columns=orc_df.columns)
if need_fix:
fix_example_values(orc_df, expected_df)
check_example_values(orc_df, expected_df)
# Exercise ORCFile.read_stripe()
json_pos = 0
for i in range(orc_file.nstripes):
batch = orc_file.read_stripe(i)
check_example_values(pd.DataFrame(batch.to_pydict()),
expected_df,
start=json_pos,
stop=json_pos + len(batch))
json_pos += len(batch)
assert json_pos == orc_file.nrows
@pytest.mark.pandas
@pytest.mark.parametrize('filename', [
'TestOrcFile.test1.orc',
'TestOrcFile.testDate1900.orc',
'decimal.orc'
])
def test_example_using_json(filename, datadir):
"""
Check a ORC file example against the equivalent JSON file, as given
in the Apache ORC repository (the JSON file has one JSON object per
line, corresponding to one row in the ORC file).
"""
# Read JSON file
path = datadir / filename
table = pd.read_json(str(path.with_suffix('.jsn.gz')), lines=True)
check_example_file(path, table, need_fix=True)
def test_orcfile_empty(datadir):
from pyarrow import orc
table = orc.ORCFile(datadir / "TestOrcFile.emptyFile.orc").read()
assert table.num_rows == 0
expected_schema = pa.schema([
("boolean1", pa.bool_()),
("byte1", pa.int8()),
("short1", pa.int16()),
("int1", pa.int32()),
("long1", pa.int64()),
("float1", pa.float32()),
("double1", pa.float64()),
("bytes1", pa.binary()),
("string1", pa.string()),
("middle", pa.struct(
[("list", pa.list_(
pa.struct([("int1", pa.int32()),
("string1", pa.string())])))
])),
("list", pa.list_(
pa.struct([("int1", pa.int32()),
("string1", pa.string())])
)),
("map", pa.map_(pa.string(),
pa.struct([("int1", pa.int32()),
("string1", pa.string())])
)),
])
assert table.schema == expected_schema
def test_orcfile_readwrite():
from pyarrow import orc
buffer_output_stream = pa.BufferOutputStream()
a = pa.array([1, None, 3, None])
b = pa.array([None, "Arrow", None, "ORC"])
table = pa.table({"int64": a, "utf8": b})
orc.write_table(buffer_output_stream, table)
buffer_reader = pa.BufferReader(buffer_output_stream.getvalue())
output_table = orc.ORCFile(buffer_reader).read()
assert table.equals(output_table)
| apache-2.0 |
aaren/notedown | notedown/main.py | 1 | 10523 | from __future__ import absolute_import
from __future__ import print_function
import os
import sys
import argparse
import pkg_resources
import io
import logging
import nbformat as nbformat
from nbconvert.utils.io import unicode_std_stream
from .notedown import (MarkdownReader,
MarkdownWriter,
Knitr,
run,
strip)
try:
__version__ = pkg_resources.require('notedown')[0].version
except pkg_resources.DistributionNotFound:
__version__ = 'testing'
markdown_template \
= pkg_resources.resource_filename('notedown',
'templates/markdown.tpl')
markdown_figure_template \
= pkg_resources.resource_filename('notedown',
'templates/markdown_outputs.tpl')
examples = """
Example usage of notedown
-------------------------
Convert markdown into notebook:
notedown input.md > output.ipynb
notedown input.md --output output.ipynb
Convert a notebook into markdown, with outputs intact:
notedown input.ipynb --from notebook --to markdown > output_with_outputs.md
Convert a notebook into markdown, stripping all outputs:
notedown input.ipynb --from notebook --to markdown --strip > output.md
Strip the output cells from markdown:
notedown with_output_cells.md --to markdown --strip > no_output_cells.md
Convert from markdown and execute:
notedown input.md --run > executed_notebook.ipynb
Convert r-markdown into markdown:
notedown input.Rmd --to markdown --knit > output.md
Convert r-markdown into an IPython notebook:
notedown input.Rmd --knit > output.ipynb
Convert r-markdown into a notebook with the outputs computed, using
the rmagic extension to execute the code blocks:
notedown input.Rmd --knit --rmagic --run > executed_output.ipynb
"""
def convert(content, informat, outformat, strip_outputs=False):
if os.path.exists(content):
with io.open(content, 'r', encoding='utf-8') as f:
contents = f.read()
else:
contents = content
readers = {'notebook': nbformat,
'markdown': MarkdownReader(precode='',
magic=False,
match='fenced')
}
writers = {'notebook': nbformat,
'markdown': MarkdownWriter(markdown_template,
strip_outputs=strip_outputs)
}
reader = readers[informat]
writer = writers[outformat]
notebook = reader.reads(contents, as_version=4)
return writer.writes(notebook)
def ftdetect(filename):
"""Determine if filename is markdown or notebook,
based on the file extension.
"""
_, extension = os.path.splitext(filename)
md_exts = ['.md', '.markdown', '.mkd', '.mdown', '.mkdn', '.Rmd']
nb_exts = ['.ipynb']
if extension in md_exts:
return 'markdown'
elif extension in nb_exts:
return 'notebook'
else:
return None
def command_line_parser():
"""Create parser for command line usage."""
description = "Create an IPython notebook from markdown."
example_use = "Example: notedown some_markdown.md > new_notebook.ipynb"
parser = argparse.ArgumentParser(description=description,
epilog=example_use)
parser.add_argument('input_file',
help="markdown input file (default STDIN)",
nargs="?",
default='-')
parser.add_argument('-o', '--output',
help=("output file, (default STDOUT). "
"If flag used but no file given, use "
"the name of the input file to "
"determine the output filename. "
"This will OVERWRITE if input and output "
"formats are the same."),
nargs="?",
default='-',
const='')
parser.add_argument('--from',
dest='informat',
choices=('notebook', 'markdown'),
help=("format to convert from, defaults to markdown "
"or file extension"))
parser.add_argument('--to',
dest='outformat',
choices=('notebook', 'markdown'),
help=("format to convert to, defaults to notebook "
"or file extension. Setting --render forces "
"this to 'markdown'"))
parser.add_argument('--run', '--execute',
action='store_true',
help=("run the notebook, executing the "
"contents of each cell"))
parser.add_argument('--timeout',
default=30,
type=int,
help=("set the cell execution timeout (in seconds)"))
parser.add_argument('--strip',
action='store_true',
dest='strip_outputs',
help=("strip output cells"))
parser.add_argument('--precode',
nargs='+',
default=[],
help=("additional code to place at the start of the "
"notebook, e.g. --pre '%%matplotlib inline' "
"'import numpy as np'"))
parser.add_argument('--knit',
nargs='?',
help=("pre-process the markdown with knitr. "
"Default chunk options are 'eval=FALSE' "
"but you can change this by passing a string. "
"Requires R in your path and knitr installed."),
const='eval=FALSE')
parser.add_argument('--rmagic',
action='store_true',
help=("autoload the rmagic extension. Synonym for "
"--precode '%%load_ext rpy2.ipython'"))
parser.add_argument('--nomagic',
action='store_false',
dest='magic',
help=("disable code magic."))
parser.add_argument('--render',
help=('render outputs, forcing markdown output'),
action='store_true')
parser.add_argument('--template',
help=('template file'))
parser.add_argument('--match',
default='all',
help=("determine kind of code blocks that get "
"converted into code cells. "
"choose from 'all' (default), 'fenced', "
"'strict' or a specific language to match on"))
parser.add_argument('--examples',
help=('show example usage'),
action='store_true')
parser.add_argument('--version',
help=('print version number'),
action='store_true')
parser.add_argument('--debug',
help=('show logging output'),
action='store_true')
return parser
def main(args, help=''):
if args.debug:
logging.basicConfig(level=logging.DEBUG)
if args.version:
print(__version__)
sys.exit()
if args.examples:
print(examples)
sys.exit()
# if no stdin and no input file
if args.input_file == '-' and sys.stdin.isatty():
sys.stdout.write(help)
sys.exit()
elif args.input_file == '-':
input_file = sys.stdin
elif args.input_file != '-':
input_file = io.open(args.input_file, 'r', encoding='utf-8')
else:
sys.exit('malformed input')
# pre-process markdown by using knitr on it
if args.knit:
knitr = Knitr()
input_file = knitr.knit(input_file, opts_chunk=args.knit)
if args.rmagic:
args.precode.append(r"%load_ext rpy2.ipython")
if args.render:
template_file = markdown_figure_template
else:
template_file = markdown_template
template_file = args.template or template_file
# reader and writer classes with args and kwargs to
# instantiate with
readers = {'notebook': nbformat,
'markdown': MarkdownReader(precode='\n'.join(args.precode),
magic=args.magic,
match=args.match,
caption_comments=args.render)
}
writers = {'notebook': nbformat,
'markdown': MarkdownWriter(template_file,
strip_outputs=args.strip_outputs)
}
informat = args.informat or ftdetect(input_file.name) or 'markdown'
outformat = args.outformat or ftdetect(args.output) or 'notebook'
if args.render:
outformat = 'markdown'
reader = readers[informat]
writer = writers[outformat]
with input_file as ip:
notebook = reader.read(ip, as_version=4)
if args.run:
run(notebook, timeout=args.timeout)
if args.strip_outputs:
strip(notebook)
output_ext = {'markdown': '.md',
'notebook': '.ipynb'}
if not args.output and args.input_file != '-':
# overwrite
fout = os.path.splitext(args.input_file)[0] + output_ext[outformat]
# grab the output here so we don't obliterate the file if
# there is an error
output = writer.writes(notebook)
with io.open(fout, 'w', encoding='utf-8') as op:
op.write(output)
elif not args.output and args.input_file == '-':
# overwrite error (input is stdin)
sys.exit('Cannot overwrite with no input file given.')
elif args.output == '-':
# write stdout
writer.write(notebook, unicode_std_stream('stdout'))
elif args.output != '-':
# write to filename
with io.open(args.output, 'w', encoding='utf-8') as op:
writer.write(notebook, op)
def app():
parser = command_line_parser()
args = parser.parse_args()
main(args, help=parser.format_help())
if __name__ == '__main__':
app()
| bsd-2-clause |
kvr777/deep-learning | weight-initialization/helper.py | 153 | 3649 | import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
def hist_dist(title, distribution_tensor, hist_range=(-4, 4)):
"""
Display histogram of a TF distribution
"""
with tf.Session() as sess:
values = sess.run(distribution_tensor)
plt.title(title)
plt.hist(values, np.linspace(*hist_range, num=len(values)/2))
plt.show()
def _get_loss_acc(dataset, weights):
"""
Get losses and validation accuracy of example neural network
"""
batch_size = 128
epochs = 2
learning_rate = 0.001
features = tf.placeholder(tf.float32)
labels = tf.placeholder(tf.float32)
learn_rate = tf.placeholder(tf.float32)
biases = [
tf.Variable(tf.zeros([256])),
tf.Variable(tf.zeros([128])),
tf.Variable(tf.zeros([dataset.train.labels.shape[1]]))
]
# Layers
layer_1 = tf.nn.relu(tf.matmul(features, weights[0]) + biases[0])
layer_2 = tf.nn.relu(tf.matmul(layer_1, weights[1]) + biases[1])
logits = tf.matmul(layer_2, weights[2]) + biases[2]
# Training loss
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels))
# Optimizer
optimizer = tf.train.AdamOptimizer(learn_rate).minimize(loss)
# Accuracy
correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# Measurements use for graphing loss
loss_batch = []
with tf.Session() as session:
session.run(tf.global_variables_initializer())
batch_count = int((dataset.train.num_examples / batch_size))
# The training cycle
for epoch_i in range(epochs):
for batch_i in range(batch_count):
batch_features, batch_labels = dataset.train.next_batch(batch_size)
# Run optimizer and get loss
session.run(
optimizer,
feed_dict={features: batch_features, labels: batch_labels, learn_rate: learning_rate})
l = session.run(
loss,
feed_dict={features: batch_features, labels: batch_labels, learn_rate: learning_rate})
loss_batch.append(l)
valid_acc = session.run(
accuracy,
feed_dict={features: dataset.validation.images, labels: dataset.validation.labels, learn_rate: 1.0})
# Hack to Reset batches
dataset.train._index_in_epoch = 0
dataset.train._epochs_completed = 0
return loss_batch, valid_acc
def compare_init_weights(
dataset,
title,
weight_init_list,
plot_n_batches=100):
"""
Plot loss and print stats of weights using an example neural network
"""
colors = ['r', 'b', 'g', 'c', 'y', 'k']
label_accs = []
label_loss = []
assert len(weight_init_list) <= len(colors), 'Too many inital weights to plot'
for i, (weights, label) in enumerate(weight_init_list):
loss, val_acc = _get_loss_acc(dataset, weights)
plt.plot(loss[:plot_n_batches], colors[i], label=label)
label_accs.append((label, val_acc))
label_loss.append((label, loss[-1]))
plt.title(title)
plt.xlabel('Batches')
plt.ylabel('Loss')
plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
plt.show()
print('After 858 Batches (2 Epochs):')
print('Validation Accuracy')
for label, val_acc in label_accs:
print(' {:7.3f}% -- {}'.format(val_acc*100, label))
print('Loss')
for label, loss in label_loss:
print(' {:7.3f} -- {}'.format(loss, label))
| mit |
OpenDroneMap/OpenDroneMap | opendm/dem/ground_rectification/rectify.py | 2 | 7435 | import argparse
import numpy as np
from os import path
from sklearn.neighbors import BallTree
from sklearn.linear_model import RANSACRegressor
from .extra_dimensions.distance_dimension import DistanceDimension
from .extra_dimensions.partition_dimension import PartitionDimension
from .extra_dimensions.extended_dimension import ExtendedDimension
from .grid.builder import build_grid
from .bounds.utils import calculate_convex_hull_bounds
from .io.las_io import read_cloud, write_cloud
from .partition.selector import select_partition_plan
from .point_cloud import PointCloud
EPSILON = 0.00001
def run_rectification(**kwargs):
header, point_cloud = read_cloud(kwargs['input'])
if 'reclassify_plan' in kwargs and kwargs['reclassify_plan'] is not None:
point_cloud = reclassify_cloud(point_cloud, kwargs['reclassify_plan'], kwargs['reclassify_threshold'], kwargs['min_points'], kwargs['min_area'])
if 'extend_plan' in kwargs and kwargs['extend_plan'] is not None:
point_cloud = extend_cloud(point_cloud, kwargs['extend_plan'], kwargs['extend_grid_distance'], kwargs['min_points'], kwargs['min_area'])
write_cloud(header, point_cloud, kwargs['output'], kwargs['debug'])
def reclassify_cloud(point_cloud, plan, threshold, min_points, min_area):
# Get only ground
ground_cloud = point_cloud[point_cloud.classification == 2]
# Get the partition plan, according to the specified criteria
partition_plan = select_partition_plan(plan, ground_cloud)
# Execute the partition plan, and get all the partitions
partitions = [result for result in partition_plan.execute(min_points=min_points, min_area=min_area)]
# Add 'distance to ground' and 'partition number' dimensions to the cloud
for dimension in [DistanceDimension(), PartitionDimension('reclassify_partition')]:
# Calculate new dimension for partition
for partition in partitions:
dimension.assign(partition.point_cloud)
# Update new data to the original point cloud
point_cloud.update(partition.point_cloud)
# Calculate the points that need to be reclassified
mask = point_cloud.get_extra_dimension_values('distance_to_ground') > threshold
# Reclassify them as 'unclassified'
point_cloud.classification[mask] = 1
return point_cloud
def extend_cloud(point_cloud, plan, distance, min_points, min_area):
# Get only ground
ground_cloud = point_cloud[point_cloud.classification == 2]
# Read the bounds file
bounds = calculate_convex_hull_bounds(ground_cloud.get_xy())
# Generate a grid of 2D points inside the bounds, with a distance of 'distance' between them
grid_2d = build_grid(bounds, ground_cloud, distance)
# Create a new point cloud
grid_3d = PointCloud.with_xy(grid_2d)
# Get the partition plan, according to the specified criteria
partition_plan = select_partition_plan(plan, ground_cloud)
# Execute the partition plan, and get all the partitions
partitions = partition_plan.execute(distance=distance, min_points=min_points, min_area=min_area, bounds=bounds)
# Create dimensions
partition_dimension = PartitionDimension('extend_partition')
extended_dimension = ExtendedDimension()
for partition in partitions:
# Keep the grid point that are inside the partition
grid_inside = partition.bounds.keep_points_inside(grid_3d)
if grid_inside.len() > 0:
# In each partition, calculate the altitude of the grid points
new_points = __calculate_new_points(grid_inside, partition.point_cloud)
# Assign the dimension values
partition_dimension.assign(new_points, partition.point_cloud)
extended_dimension.assign(new_points)
# Update the original 3d grid with the new calculated points
grid_3d.update(new_points)
else:
# Assign the original points the correct partition
partition_dimension.assign(partition.point_cloud)
# Update new information to the original point cloud
point_cloud.update(partition.point_cloud)
# Calculate the bounding box of the original cloud
bbox = point_cloud.get_bounding_box()
# Remove points that might have ended up outside the bbox
grid_3d = bbox.keep_points_inside(grid_3d)
# Add the new grid points to the original cloud
point_cloud.concatenate(grid_3d)
# Add the new points to the original point cloud
return point_cloud
def __calculate_new_points(grid_points_inside, partition_point_cloud):
# Calculate RANSCAC model
model = RANSACRegressor().fit(partition_point_cloud.get_xy(), partition_point_cloud.get_z())
# With the ransac model, calculate the altitude for each grid point
grid_points_altitude = model.predict(grid_points_inside.get_xy())
# Calculate color for new points
[avg_red, avg_green, avg_blue] = np.mean(partition_point_cloud.rgb, axis=0)
red = np.full(grid_points_inside.len(), avg_red)
green = np.full(grid_points_inside.len(), avg_green)
blue = np.full(grid_points_inside.len(), avg_blue)
# Classify all new points as ground
classification = np.full(grid_points_inside.len(), 2, dtype=np.uint8)
# Split xy into columns
[x, y] = np.hsplit(grid_points_inside.get_xy(), 2)
# Return point cloud
return PointCloud.with_dimensions(x.ravel(), y.ravel(), grid_points_altitude, classification, red, green, blue, grid_points_inside.indices)
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='This script takes a pre-classified point cloud, and then it re-clasiffies wrongly classified ground point to non-ground points and finally adds ground points where needed.')
parser.add_argument('input', type=str, help='The path where to find the pre-classified point cloud.')
parser.add_argument('output', type=str, help='The path where to save the rectified point cloud.')
parser.add_argument('--reclassify_plan', type=str, help='The partition plan to use reclasiffication. Must be one of(one, uniform, median, surrounding)')
parser.add_argument('--reclassify_threshold', type=float, help='Every point with a distance to the estimated ground that is higher than the threshold will be reclassified as non ground', default=5)
parser.add_argument('--extend_plan', type=str, help='The partition plan to use for extending the ground. Must be one of(one, uniform, median, surrounding)')
parser.add_argument('--extend_grid_distance', type=float, help='The distance between points on the grid that will be added to the point cloud.', default=5)
parser.add_argument('--min_area', type=int, help='Some partition plans need a minimum area as a stopping criteria.', default=750)
parser.add_argument('--min_points', type=int, help='Some partition plans need a minimum number of points as a stopping criteria.', default=500)
args = parser.parse_args()
if args.reclassify_plan is None and args.extend_plan is None:
raise Exception("Please set a reclassifying or extension plan. Otherwise there is nothing for me to do.")
run(input=args.input, reclassify_plan=args.reclassify_plan, reclassify_threshold=args.reclassify_threshold, \
extend_plan=args.extend_plan, extend_grid_distance=args.extend_grid_distance, \
output=args.output, min_points=args.min_points, min_area=args.min_area, debug=False)
| gpl-3.0 |
kjung/scikit-learn | examples/svm/plot_svm_scale_c.py | 44 | 5405 | """
==============================================
Scaling the regularization parameter for SVCs
==============================================
The following example illustrates the effect of scaling the
regularization parameter when using :ref:`svm` for
:ref:`classification <svm_classification>`.
For SVC classification, we are interested in a risk minimization for the
equation:
.. math::
C \sum_{i=1, n} \mathcal{L} (f(x_i), y_i) + \Omega (w)
where
- :math:`C` is used to set the amount of regularization
- :math:`\mathcal{L}` is a `loss` function of our samples
and our model parameters.
- :math:`\Omega` is a `penalty` function of our model parameters
If we consider the loss function to be the individual error per
sample, then the data-fit term, or the sum of the error for each sample, will
increase as we add more samples. The penalization term, however, will not
increase.
When using, for example, :ref:`cross validation <cross_validation>`, to
set the amount of regularization with `C`, there will be a
different amount of samples between the main problem and the smaller problems
within the folds of the cross validation.
Since our loss function is dependent on the amount of samples, the latter
will influence the selected value of `C`.
The question that arises is `How do we optimally adjust C to
account for the different amount of training samples?`
The figures below are used to illustrate the effect of scaling our
`C` to compensate for the change in the number of samples, in the
case of using an `l1` penalty, as well as the `l2` penalty.
l1-penalty case
-----------------
In the `l1` case, theory says that prediction consistency
(i.e. that under given hypothesis, the estimator
learned predicts as well as a model knowing the true distribution)
is not possible because of the bias of the `l1`. It does say, however,
that model consistency, in terms of finding the right set of non-zero
parameters as well as their signs, can be achieved by scaling
`C1`.
l2-penalty case
-----------------
The theory says that in order to achieve prediction consistency, the
penalty parameter should be kept constant
as the number of samples grow.
Simulations
------------
The two figures below plot the values of `C` on the `x-axis` and the
corresponding cross-validation scores on the `y-axis`, for several different
fractions of a generated data-set.
In the `l1` penalty case, the cross-validation-error correlates best with
the test-error, when scaling our `C` with the number of samples, `n`,
which can be seen in the first figure.
For the `l2` penalty case, the best result comes from the case where `C`
is not scaled.
.. topic:: Note:
Two separate datasets are used for the two different plots. The reason
behind this is the `l1` case works better on sparse data, while `l2`
is better suited to the non-sparse case.
"""
print(__doc__)
# Author: Andreas Mueller <[email protected]>
# Jaques Grobler <[email protected]>
# License: BSD 3 clause
import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import LinearSVC
from sklearn.model_selection import ShuffleSplit
from sklearn.model_selection import GridSearchCV
from sklearn.utils import check_random_state
from sklearn import datasets
rnd = check_random_state(1)
# set up dataset
n_samples = 100
n_features = 300
# l1 data (only 5 informative features)
X_1, y_1 = datasets.make_classification(n_samples=n_samples,
n_features=n_features, n_informative=5,
random_state=1)
# l2 data: non sparse, but less features
y_2 = np.sign(.5 - rnd.rand(n_samples))
X_2 = rnd.randn(n_samples, n_features / 5) + y_2[:, np.newaxis]
X_2 += 5 * rnd.randn(n_samples, n_features / 5)
clf_sets = [(LinearSVC(penalty='l1', loss='squared_hinge', dual=False,
tol=1e-3),
np.logspace(-2.3, -1.3, 10), X_1, y_1),
(LinearSVC(penalty='l2', loss='squared_hinge', dual=True,
tol=1e-4),
np.logspace(-4.5, -2, 10), X_2, y_2)]
colors = ['navy', 'cyan', 'darkorange']
lw = 2
for fignum, (clf, cs, X, y) in enumerate(clf_sets):
# set up the plot for each regressor
plt.figure(fignum, figsize=(9, 10))
for k, train_size in enumerate(np.linspace(0.3, 0.7, 3)[::-1]):
param_grid = dict(C=cs)
# To get nice curve, we need a large number of iterations to
# reduce the variance
grid = GridSearchCV(clf, refit=False, param_grid=param_grid,
cv=ShuffleSplit(train_size=train_size, n_iter=250,
random_state=1))
grid.fit(X, y)
scores = [x[1] for x in grid.grid_scores_]
scales = [(1, 'No scaling'),
((n_samples * train_size), '1/n_samples'),
]
for subplotnum, (scaler, name) in enumerate(scales):
plt.subplot(2, 1, subplotnum + 1)
plt.xlabel('C')
plt.ylabel('CV Score')
grid_cs = cs * float(scaler) # scale the C's
plt.semilogx(grid_cs, scores, label="fraction %.2f" %
train_size, color=colors[k], lw=lw)
plt.title('scaling=%s, penalty=%s, loss=%s' %
(name, clf.penalty, clf.loss))
plt.legend(loc="best")
plt.show()
| bsd-3-clause |
ammarkhann/FinalSeniorCode | lib/python2.7/site-packages/matplotlib/tests/test_basic.py | 5 | 1550 | from __future__ import (absolute_import, division, print_function,
unicode_literals)
import six
import warnings
from nose.tools import assert_equal
from matplotlib.cbook import MatplotlibDeprecationWarning
from matplotlib.testing.decorators import knownfailureif
with warnings.catch_warnings():
warnings.filterwarnings('ignore',
'The finance module has been deprecated in mpl 2',
MatplotlibDeprecationWarning)
from pylab import *
def test_simple():
assert_equal(1 + 1, 2)
@knownfailureif(True)
def test_simple_knownfail():
# Test the known fail mechanism.
assert_equal(1 + 1, 3)
def test_override_builtins():
ok_to_override = set([
'__name__',
'__doc__',
'__package__',
'__loader__',
'__spec__',
'any',
'all',
'sum'
])
# We could use six.moves.builtins here, but that seems
# to do a little more than just this.
if six.PY3:
builtins = sys.modules['builtins']
else:
builtins = sys.modules['__builtin__']
overridden = False
for key in globals().keys():
if key in dir(builtins):
if (globals()[key] != getattr(builtins, key) and
key not in ok_to_override):
print("'%s' was overridden in globals()." % key)
overridden = True
assert not overridden
if __name__ == '__main__':
import nose
nose.runmodule(argv=['-s', '--with-doctest'], exit=False)
| mit |
Aircollition/Aircollition | Python scripts/Script_10_SplittingvcMC.py | 1 | 3115 | import numpy as np
import numpy.random as npr
import matplotlib.pyplot as plt
from scipy.stats import mvn
from LaTeXPy import latexify
def func(U, epsilon):
# Computes the prob any (U_i) is less than epsilon
ind = np.any(U < epsilon, axis = 1)
return ind
def quant(X, alpha):
G = np.sort(X)
size = G.size
index = int(size * alpha)
return G[index]
def phi(X):
out = np.min(X, axis = 1)
return out
epsilon = 0.1 # Choc distance
Nsim = 10**5 # number of Monte Carlo simulations
npoint = 20 # numper of points in the trajectory
Time = 100.0
dmax = 8
v=500.0/60.0 # airplane speed
rc=1.0/57 # param
sigmac=1.0 # param
t = np.linspace(0, Time, npoint);
cov = np.zeros((npoint,npoint), dtype = float)
for i in range(npoint):
for j in range(npoint):
cov[i,j] = 2 * sigmac**2 * (1-np.exp(-2*rc*v*min(t[i],t[j])/sigmac)) * np.exp(-rc*v*np.abs(t[i]-t[j])/sigmac)
A = []
B = []
for distance in np.linspace(0, dmax, 20):
mean = distance * np.ones((npoint,), dtype = float)
# FIN DEFINITION DU PROCESSUS
# Simulation des vecteurs gaussiens
X = np.random.multivariate_normal(mean, cov, size=Nsim)
# Monte Carlo method to calculate the probability
ind_mc = func(X, epsilon)
p_emp_MC = np.mean(ind_mc)
erreur_MC = 1.96*np.sqrt(p_emp_MC*(1-p_emp_MC)/Nsim)
# Splitting Method
# Quantile function
N = 10**5
alpha = 0.5 # quantile level for adapt threshld
X = np.random.multivariate_normal(mean, cov, size=N)
rho = 0.5 # param markovian kernel
nu = np.sqrt(1-rho**2)
S = 0.1 # threshold to be exeeded
q_alpha = quant(phi(X), alpha) # Estimation of quantile
eye = np.eye(npoint) # auxiliary
i = 0
while(q_alpha > S):
w = (phi(X)<q_alpha) # weights for resampling
while(np.sum(w)==0):
X = np.random.multivariate_normal(mean, cov, size=N)
w = (phi(X)<q_alpha)
w = w /np.sum(w)
ind = npr.choice(np.arange(N), size = N, replace = True, p = w) # resampling
Y = X[ind] # resampling
p = rho*Y+nu*np.random.multivariate_normal(mean, eye, size=N) # Markovian kernel application
aux1 = (p.T*(phi(p)<q_alpha)).T
aux2 = (Y.T*(phi(p)>=q_alpha)).T
X = aux1 + aux2 # new population
q_alpha = quant(phi(X), alpha) # position of the next threshold
i=i+1
proba = (1-alpha)**i * np.mean(phi(X)<S) # probability estimation with splitting
A.append(p_emp_MC)
B.append(proba)
low = epsilon * np.ones(npoint)
upp = 100 * np.ones(npoint)
P = []
for distance in np.linspace(0,8,100):
mean = distance * np.ones(npoint)
p,i = mvn.mvnun(low,upp,mean,cov)
P.append(1-p)
latexify()
plt.figure()
plt.grid(True)
plt.semilogy(np.linspace(0, dmax, 20), A, 'rx', label = 'MC')
plt.semilogy(np.linspace(0, dmax, 20), B, 'b.', label ='Splitting')
plt.semilogy(np.linspace(0, 8, 100), P, 'k', label ='num')
plt.xlabel("Separation distance")
plt.ylabel("Probability")
plt.legend()
plt.savefig('Outputs/Script_10_SplittingvsMC.pdf', bbox_inches='tight') | mit |
nesterione/scikit-learn | sklearn/kernel_approximation.py | 258 | 17973 | """
The :mod:`sklearn.kernel_approximation` module implements several
approximate kernel feature maps base on Fourier transforms.
"""
# Author: Andreas Mueller <[email protected]>
#
# License: BSD 3 clause
import warnings
import numpy as np
import scipy.sparse as sp
from scipy.linalg import svd
from .base import BaseEstimator
from .base import TransformerMixin
from .utils import check_array, check_random_state, as_float_array
from .utils.extmath import safe_sparse_dot
from .utils.validation import check_is_fitted
from .metrics.pairwise import pairwise_kernels
class RBFSampler(BaseEstimator, TransformerMixin):
"""Approximates feature map of an RBF kernel by Monte Carlo approximation
of its Fourier transform.
It implements a variant of Random Kitchen Sinks.[1]
Read more in the :ref:`User Guide <rbf_kernel_approx>`.
Parameters
----------
gamma : float
Parameter of RBF kernel: exp(-gamma * x^2)
n_components : int
Number of Monte Carlo samples per original feature.
Equals the dimensionality of the computed feature space.
random_state : {int, RandomState}, optional
If int, random_state is the seed used by the random number generator;
if RandomState instance, random_state is the random number generator.
Notes
-----
See "Random Features for Large-Scale Kernel Machines" by A. Rahimi and
Benjamin Recht.
[1] "Weighted Sums of Random Kitchen Sinks: Replacing
minimization with randomization in learning" by A. Rahimi and
Benjamin Recht.
(http://www.eecs.berkeley.edu/~brecht/papers/08.rah.rec.nips.pdf)
"""
def __init__(self, gamma=1., n_components=100, random_state=None):
self.gamma = gamma
self.n_components = n_components
self.random_state = random_state
def fit(self, X, y=None):
"""Fit the model with X.
Samples random projection according to n_features.
Parameters
----------
X : {array-like, sparse matrix}, shape (n_samples, n_features)
Training data, where n_samples in the number of samples
and n_features is the number of features.
Returns
-------
self : object
Returns the transformer.
"""
X = check_array(X, accept_sparse='csr')
random_state = check_random_state(self.random_state)
n_features = X.shape[1]
self.random_weights_ = (np.sqrt(2 * self.gamma) * random_state.normal(
size=(n_features, self.n_components)))
self.random_offset_ = random_state.uniform(0, 2 * np.pi,
size=self.n_components)
return self
def transform(self, X, y=None):
"""Apply the approximate feature map to X.
Parameters
----------
X : {array-like, sparse matrix}, shape (n_samples, n_features)
New data, where n_samples in the number of samples
and n_features is the number of features.
Returns
-------
X_new : array-like, shape (n_samples, n_components)
"""
check_is_fitted(self, 'random_weights_')
X = check_array(X, accept_sparse='csr')
projection = safe_sparse_dot(X, self.random_weights_)
projection += self.random_offset_
np.cos(projection, projection)
projection *= np.sqrt(2.) / np.sqrt(self.n_components)
return projection
class SkewedChi2Sampler(BaseEstimator, TransformerMixin):
"""Approximates feature map of the "skewed chi-squared" kernel by Monte
Carlo approximation of its Fourier transform.
Read more in the :ref:`User Guide <skewed_chi_kernel_approx>`.
Parameters
----------
skewedness : float
"skewedness" parameter of the kernel. Needs to be cross-validated.
n_components : int
number of Monte Carlo samples per original feature.
Equals the dimensionality of the computed feature space.
random_state : {int, RandomState}, optional
If int, random_state is the seed used by the random number generator;
if RandomState instance, random_state is the random number generator.
References
----------
See "Random Fourier Approximations for Skewed Multiplicative Histogram
Kernels" by Fuxin Li, Catalin Ionescu and Cristian Sminchisescu.
See also
--------
AdditiveChi2Sampler : A different approach for approximating an additive
variant of the chi squared kernel.
sklearn.metrics.pairwise.chi2_kernel : The exact chi squared kernel.
"""
def __init__(self, skewedness=1., n_components=100, random_state=None):
self.skewedness = skewedness
self.n_components = n_components
self.random_state = random_state
def fit(self, X, y=None):
"""Fit the model with X.
Samples random projection according to n_features.
Parameters
----------
X : array-like, shape (n_samples, n_features)
Training data, where n_samples in the number of samples
and n_features is the number of features.
Returns
-------
self : object
Returns the transformer.
"""
X = check_array(X)
random_state = check_random_state(self.random_state)
n_features = X.shape[1]
uniform = random_state.uniform(size=(n_features, self.n_components))
# transform by inverse CDF of sech
self.random_weights_ = (1. / np.pi
* np.log(np.tan(np.pi / 2. * uniform)))
self.random_offset_ = random_state.uniform(0, 2 * np.pi,
size=self.n_components)
return self
def transform(self, X, y=None):
"""Apply the approximate feature map to X.
Parameters
----------
X : array-like, shape (n_samples, n_features)
New data, where n_samples in the number of samples
and n_features is the number of features.
Returns
-------
X_new : array-like, shape (n_samples, n_components)
"""
check_is_fitted(self, 'random_weights_')
X = as_float_array(X, copy=True)
X = check_array(X, copy=False)
if (X < 0).any():
raise ValueError("X may not contain entries smaller than zero.")
X += self.skewedness
np.log(X, X)
projection = safe_sparse_dot(X, self.random_weights_)
projection += self.random_offset_
np.cos(projection, projection)
projection *= np.sqrt(2.) / np.sqrt(self.n_components)
return projection
class AdditiveChi2Sampler(BaseEstimator, TransformerMixin):
"""Approximate feature map for additive chi2 kernel.
Uses sampling the fourier transform of the kernel characteristic
at regular intervals.
Since the kernel that is to be approximated is additive, the components of
the input vectors can be treated separately. Each entry in the original
space is transformed into 2*sample_steps+1 features, where sample_steps is
a parameter of the method. Typical values of sample_steps include 1, 2 and
3.
Optimal choices for the sampling interval for certain data ranges can be
computed (see the reference). The default values should be reasonable.
Read more in the :ref:`User Guide <additive_chi_kernel_approx>`.
Parameters
----------
sample_steps : int, optional
Gives the number of (complex) sampling points.
sample_interval : float, optional
Sampling interval. Must be specified when sample_steps not in {1,2,3}.
Notes
-----
This estimator approximates a slightly different version of the additive
chi squared kernel then ``metric.additive_chi2`` computes.
See also
--------
SkewedChi2Sampler : A Fourier-approximation to a non-additive variant of
the chi squared kernel.
sklearn.metrics.pairwise.chi2_kernel : The exact chi squared kernel.
sklearn.metrics.pairwise.additive_chi2_kernel : The exact additive chi
squared kernel.
References
----------
See `"Efficient additive kernels via explicit feature maps"
<http://www.robots.ox.ac.uk/~vedaldi/assets/pubs/vedaldi11efficient.pdf>`_
A. Vedaldi and A. Zisserman, Pattern Analysis and Machine Intelligence,
2011
"""
def __init__(self, sample_steps=2, sample_interval=None):
self.sample_steps = sample_steps
self.sample_interval = sample_interval
def fit(self, X, y=None):
"""Set parameters."""
X = check_array(X, accept_sparse='csr')
if self.sample_interval is None:
# See reference, figure 2 c)
if self.sample_steps == 1:
self.sample_interval_ = 0.8
elif self.sample_steps == 2:
self.sample_interval_ = 0.5
elif self.sample_steps == 3:
self.sample_interval_ = 0.4
else:
raise ValueError("If sample_steps is not in [1, 2, 3],"
" you need to provide sample_interval")
else:
self.sample_interval_ = self.sample_interval
return self
def transform(self, X, y=None):
"""Apply approximate feature map to X.
Parameters
----------
X : {array-like, sparse matrix}, shape = (n_samples, n_features)
Returns
-------
X_new : {array, sparse matrix}, \
shape = (n_samples, n_features * (2*sample_steps + 1))
Whether the return value is an array of sparse matrix depends on
the type of the input X.
"""
msg = ("%(name)s is not fitted. Call fit to set the parameters before"
" calling transform")
check_is_fitted(self, "sample_interval_", msg=msg)
X = check_array(X, accept_sparse='csr')
sparse = sp.issparse(X)
# check if X has negative values. Doesn't play well with np.log.
if ((X.data if sparse else X) < 0).any():
raise ValueError("Entries of X must be non-negative.")
# zeroth component
# 1/cosh = sech
# cosh(0) = 1.0
transf = self._transform_sparse if sparse else self._transform_dense
return transf(X)
def _transform_dense(self, X):
non_zero = (X != 0.0)
X_nz = X[non_zero]
X_step = np.zeros_like(X)
X_step[non_zero] = np.sqrt(X_nz * self.sample_interval_)
X_new = [X_step]
log_step_nz = self.sample_interval_ * np.log(X_nz)
step_nz = 2 * X_nz * self.sample_interval_
for j in range(1, self.sample_steps):
factor_nz = np.sqrt(step_nz /
np.cosh(np.pi * j * self.sample_interval_))
X_step = np.zeros_like(X)
X_step[non_zero] = factor_nz * np.cos(j * log_step_nz)
X_new.append(X_step)
X_step = np.zeros_like(X)
X_step[non_zero] = factor_nz * np.sin(j * log_step_nz)
X_new.append(X_step)
return np.hstack(X_new)
def _transform_sparse(self, X):
indices = X.indices.copy()
indptr = X.indptr.copy()
data_step = np.sqrt(X.data * self.sample_interval_)
X_step = sp.csr_matrix((data_step, indices, indptr),
shape=X.shape, dtype=X.dtype, copy=False)
X_new = [X_step]
log_step_nz = self.sample_interval_ * np.log(X.data)
step_nz = 2 * X.data * self.sample_interval_
for j in range(1, self.sample_steps):
factor_nz = np.sqrt(step_nz /
np.cosh(np.pi * j * self.sample_interval_))
data_step = factor_nz * np.cos(j * log_step_nz)
X_step = sp.csr_matrix((data_step, indices, indptr),
shape=X.shape, dtype=X.dtype, copy=False)
X_new.append(X_step)
data_step = factor_nz * np.sin(j * log_step_nz)
X_step = sp.csr_matrix((data_step, indices, indptr),
shape=X.shape, dtype=X.dtype, copy=False)
X_new.append(X_step)
return sp.hstack(X_new)
class Nystroem(BaseEstimator, TransformerMixin):
"""Approximate a kernel map using a subset of the training data.
Constructs an approximate feature map for an arbitrary kernel
using a subset of the data as basis.
Read more in the :ref:`User Guide <nystroem_kernel_approx>`.
Parameters
----------
kernel : string or callable, default="rbf"
Kernel map to be approximated. A callable should accept two arguments
and the keyword arguments passed to this object as kernel_params, and
should return a floating point number.
n_components : int
Number of features to construct.
How many data points will be used to construct the mapping.
gamma : float, default=None
Gamma parameter for the RBF, polynomial, exponential chi2 and
sigmoid kernels. Interpretation of the default value is left to
the kernel; see the documentation for sklearn.metrics.pairwise.
Ignored by other kernels.
degree : float, default=3
Degree of the polynomial kernel. Ignored by other kernels.
coef0 : float, default=1
Zero coefficient for polynomial and sigmoid kernels.
Ignored by other kernels.
kernel_params : mapping of string to any, optional
Additional parameters (keyword arguments) for kernel function passed
as callable object.
random_state : {int, RandomState}, optional
If int, random_state is the seed used by the random number generator;
if RandomState instance, random_state is the random number generator.
Attributes
----------
components_ : array, shape (n_components, n_features)
Subset of training points used to construct the feature map.
component_indices_ : array, shape (n_components)
Indices of ``components_`` in the training set.
normalization_ : array, shape (n_components, n_components)
Normalization matrix needed for embedding.
Square root of the kernel matrix on ``components_``.
References
----------
* Williams, C.K.I. and Seeger, M.
"Using the Nystroem method to speed up kernel machines",
Advances in neural information processing systems 2001
* T. Yang, Y. Li, M. Mahdavi, R. Jin and Z. Zhou
"Nystroem Method vs Random Fourier Features: A Theoretical and Empirical
Comparison",
Advances in Neural Information Processing Systems 2012
See also
--------
RBFSampler : An approximation to the RBF kernel using random Fourier
features.
sklearn.metrics.pairwise.kernel_metrics : List of built-in kernels.
"""
def __init__(self, kernel="rbf", gamma=None, coef0=1, degree=3,
kernel_params=None, n_components=100, random_state=None):
self.kernel = kernel
self.gamma = gamma
self.coef0 = coef0
self.degree = degree
self.kernel_params = kernel_params
self.n_components = n_components
self.random_state = random_state
def fit(self, X, y=None):
"""Fit estimator to data.
Samples a subset of training points, computes kernel
on these and computes normalization matrix.
Parameters
----------
X : array-like, shape=(n_samples, n_feature)
Training data.
"""
X = check_array(X, accept_sparse='csr')
rnd = check_random_state(self.random_state)
n_samples = X.shape[0]
# get basis vectors
if self.n_components > n_samples:
# XXX should we just bail?
n_components = n_samples
warnings.warn("n_components > n_samples. This is not possible.\n"
"n_components was set to n_samples, which results"
" in inefficient evaluation of the full kernel.")
else:
n_components = self.n_components
n_components = min(n_samples, n_components)
inds = rnd.permutation(n_samples)
basis_inds = inds[:n_components]
basis = X[basis_inds]
basis_kernel = pairwise_kernels(basis, metric=self.kernel,
filter_params=True,
**self._get_kernel_params())
# sqrt of kernel matrix on basis vectors
U, S, V = svd(basis_kernel)
S = np.maximum(S, 1e-12)
self.normalization_ = np.dot(U * 1. / np.sqrt(S), V)
self.components_ = basis
self.component_indices_ = inds
return self
def transform(self, X):
"""Apply feature map to X.
Computes an approximate feature map using the kernel
between some training points and X.
Parameters
----------
X : array-like, shape=(n_samples, n_features)
Data to transform.
Returns
-------
X_transformed : array, shape=(n_samples, n_components)
Transformed data.
"""
check_is_fitted(self, 'components_')
X = check_array(X, accept_sparse='csr')
kernel_params = self._get_kernel_params()
embedded = pairwise_kernels(X, self.components_,
metric=self.kernel,
filter_params=True,
**kernel_params)
return np.dot(embedded, self.normalization_.T)
def _get_kernel_params(self):
params = self.kernel_params
if params is None:
params = {}
if not callable(self.kernel):
params['gamma'] = self.gamma
params['degree'] = self.degree
params['coef0'] = self.coef0
return params
| bsd-3-clause |
adelomana/mendiak | saturationCurveAnalysis.py | 1 | 5371 | '''
this script creates the FASTQ files for the saturation curve
'''
import os,sys,random,numpy
import scipy,scipy.interpolate
import matplotlib,matplotlib.pyplot
def butcher(sample,iteration):
'''
this function creates crumbles of FASTQ files for curve saturation analysis
'''
# f.0. read reads (NPI)
possibleFiles=os.listdir(readsFilesDir)
inputFile=readsFilesDir+[element for element in possibleFiles if correspondance[sample] in element][0]
allReads={}
with open(inputFile,'r') as f:
count=0
for line in f:
vector=line[:-2]
count=count+1
if count == 1:
readName=vector
if count == 2:
sequence=vector
if count == 4:
quality=vector
allReads[readName]=[sequence,quality]
count=0
# f.2. go over resolution decrements, saving FASTQ files of appropriate size
allKeys=list(allReads.keys())
numberOfReads=len(allKeys)
mr=int(numberOfReads/1e6)
while mr >= 1:
print('selecting %s mr...'%mr)
# select n random reads
k=int(mr*1e6)
selectedReads=random.sample(allKeys,k)
# write a file
outputFile=piecesDir+sample+'.resolution.%s.iteration.%s.fastq'%(str(mr),str(iteration))
g=open(outputFile,'w')
for read in selectedReads:
g.write('%s\n'%read)
g.write('%s\n'%allReads[read][0])
g.write('+\n')
g.write('%s\n'%allReads[read][1])
g.close()
# next iteration
mr=mr-resolution
return None
# 0. user defined variables
readsFilesDir='/Volumes/omics4tb/alomana/projects/csp.jgi/data/fastq/clean/'
piecesDir='/Volumes/omics4tb/alomana/projects/csp.jgi/data/fastq.crumbles.n5/'
peaksDir='/Volumes/omics4tb/alomana/projects/csp.jgi/data/macs2.crumbles.n5/'
figuresDir='/Users/alomana/gDrive2/tmp/'
resolution=2
iterations=5
correspondance={}
correspondance['0hA']='ASCAO'
correspondance['0hB']='ASCAP'
correspondance['24hA']='ASCAS'
correspondance['24hB']='ASCAT'
correspondance['48hA']='ASCAU'
correspondance['48hB']='ASCAW'
finalSamples={}
finalSamples['0hA']=[33.25,30028]
finalSamples['0hB']=[10.67,9134]
finalSamples['24hA']=[21.15,35467]
finalSamples['24hB']=[15.2, 32323]
finalSamples['48hA']=[19.24,13712]
finalSamples['48hB']=[33.73,18778]
'''
# 1. iterate over samples
for sample in correspondance.keys():
# 2. create FASTQ crumbles
print('working with sample'+sample+'...')
for iteration in range(iterations):
iteration=iteration
print('working with iteration %s...'%str(iteration))
butcher(sample,iteration)
'''
# 3. figure maker
allFiles=os.listdir(peaksDir)
peakFiles=[element for element in allFiles if "_peaks.xls" in element]
# 3.1. reading data
print('reading peak data...')
saturationValues={}
for peakFileName in peakFiles:
pieces=peakFileName.split('_peaks')[0].split('.')
sampleName=pieces[1]
mr=int(pieces[3])
if sampleName not in saturationValues.keys():
saturationValues[sampleName]={}
if mr not in saturationValues[sampleName].keys():
saturationValues[sampleName][mr]=[]
peakFile=peaksDir+peakFileName
with open(peakFile,'r') as f:
lastLine=f.readlines()[-1]
vector=lastLine.split('\t')
peaksTextForm=vector[-1].split('_')[-1]
peaksTextForm=peaksTextForm.replace('\n','')
if peaksTextForm[0] == '#':
formatted=0
elif peaksTextForm[-1].isdigit() == False:
formatted=int(peaksTextForm[:-1])
else:
formatted=int(peaksTextForm)
saturationValues[sampleName][mr].append(formatted)
# 3.2. building graph
print('creating figure...')
colorSchema={}
colorSchema['0hA']='darkgreen'
colorSchema['0hB']='green'
colorSchema['24hA']='darkred'
colorSchema['24hB']='red'
colorSchema['48hA']='blue'
colorSchema['48hB']='darkblue'
allSamples=list(saturationValues.keys())
allSamples.sort()
for sample in allSamples:
x=list(saturationValues[sample].keys())
x.sort()
y=[];err=[]
for element in x:
y.append(numpy.mean(saturationValues[sample][element]))
err.append(numpy.std(saturationValues[sample][element]))
# setting up the color
theColor=colorSchema[sample]
# plotting the rest of the trajectory
matplotlib.pyplot.errorbar(x,y,yerr=err,fmt='o',color=theColor,alpha=0.5,mew=0.)
# adding final sample
finalx=finalSamples[sample][0]
finaly=finalSamples[sample][1]
matplotlib.pyplot.plot(finalx,finaly,'s',color=theColor,mew=0.)
# interpolating lines
interpolation=scipy.interpolate.PchipInterpolator(x,y)
xnew=numpy.linspace(min(x),max(x),num=500,endpoint=True)
ynew=interpolation(xnew)
matplotlib.pyplot.plot(xnew,ynew,'-',lw=2,color=theColor,label=sample)
matplotlib.pyplot.xlim([0,35])
matplotlib.pyplot.ylim([-1000,40000])
matplotlib.pyplot.xlabel('sequencing depth (mr)',fontsize=28)
matplotlib.pyplot.ylabel('peaks (x1e3)',fontsize=28)
matplotlib.pyplot.legend(loc=2)
matplotlib.pyplot.yticks([5000,10000,15000,20000,25000,30000,35000,40000],['5','10','15','20','25','30','35','40'],fontsize=20)
matplotlib.pyplot.xticks(fontsize=20)
matplotlib.pyplot.tight_layout()
matplotlib.pyplot.savefig(figuresDir+'saturationCurve.png')
| gpl-3.0 |
dmargala/blupe | python/plot_fit_tpcorr_results.py | 1 | 5943 | #!/usr/bin/env python
import argparse
import glob
import numpy as np
import matplotlib as mpl
mpl.use('Agg')
mpl.rcParams.update({'font.size': 10})
import matplotlib.pyplot as plt
def mad(arr):
"""
Median Absolute Deviation: a "Robust" version of standard deviation.
Indices variabililty of the sample.
https://en.wikipedia.org/wiki/Median_absolute_deviation
"""
arr = np.ma.array(arr).compressed() # should be faster to not use masked arrays.
med = np.median(arr)
return np.median(np.abs(arr - med))
def nmad(arr):
return 1.4826*mad(arr)
def add_stat_legend(x):
textstr = ''
textstr += '$\mathrm{N}=%d$\n' % len(x)
textstr += '$\mathrm{mean}=%.2f$\n' % np.nanmean(x)
textstr += '$\mathrm{median}=%.2f$\n' % np.nanmedian(x)
textstr += '$\mathrm{nmad}=%.2f$' % nmad(x)
props = dict(boxstyle='round', facecolor='white')
plt.text(0.95, 0.95, textstr, transform=plt.gca().transAxes,
va='top', ha='right', bbox=props)
def is_outlier(points, thresh=3.5):
"""
Returns a boolean array with True if points are outliers and False
otherwise.
Parameters:
-----------
points : An numobservations by numdimensions array of observations
thresh : The modified z-score to use as a threshold. Observations with
a modified z-score (based on the median absolute deviation) greater
than this value will be classified as outliers.
Returns:
--------
mask : A numobservations-length boolean array.
References:
----------
Boris Iglewicz and David Hoaglin (1993), "Volume 16: How to Detect and
Handle Outliers", The ASQC Basic References in Quality Control:
Statistical Techniques, Edward F. Mykytka, Ph.D., Editor.
"""
if len(points.shape) == 1:
points = points[:,None]
median = np.median(points, axis=0)
diff = np.sum((points - median)**2, axis=-1)
diff = np.sqrt(diff)
med_abs_deviation = np.median(diff)
modified_z_score = 0.6745 * diff / med_abs_deviation
return modified_z_score > thresh
def main():
# parse command-line arguments
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("--verbose", action="store_true",
help="print verbose output")
parser.add_argument("-o", "--output", type=str, default=None,
help="output file")
parser.add_argument("-i", "--input", type=str, default=None,
help="required input file")
parser.add_argument("--mask-outliers", action="store_true",
help="mask outliers in samples")
args = parser.parse_args()
filenames = glob.glob(args.input)
nfiles = len(filenames)
nparams = 3
summary = np.empty((nfiles, nparams))
for i,filename in enumerate(filenames):
# data columns:
# x0 a1 a2
data = np.loadtxt(filename, ndmin=2)
summary[i] = np.median(data, axis=0)
outlier_thres = 20
# save results summary plot
fig = plt.figure(figsize=(12,12))
ax1 = plt.subplot2grid((3,3), (0,0))
ax2 = plt.subplot2grid((3,3), (1,1))
ax3 = plt.subplot2grid((3,3), (2,2))
ax4 = plt.subplot2grid((3,3), (1,0))
ax5 = plt.subplot2grid((3,3), (2,0))
ax6 = plt.subplot2grid((3,3), (2,1))
# plot the fit parameter distributions
def plot_param_dist(x, binspec, color, xlabel):
xmin, xmax, nxbins = [element for tupl in binspec for element in tupl]
print 'Stats for %s' % xlabel
print 'min, max: %.4g, %.4g' % (xmin, xmax)
if args.mask_outliers:
mask = ~is_outlier(x, thresh=outlier_thres)
print 'number of masked entries: %d' % len(np.flatnonzero(~mask))
print 'list of masked entries and values: '
for index in np.flatnonzero(~mask):
filename = filenames[index]
print '-'.join(filename.split('.')[0].split('-')[-2:]), x[index]
x = x[mask]
print 'min, max (masked): %f, %f' % (np.min(x), np.max(x))
print
plt.hist(x, bins=np.linspace(xmin, xmax, nxbins+1), facecolor=color, alpha=.5, histtype='stepfilled')
plt.xlabel(xlabel)
plt.xlim([xmin, xmax])
plt.grid()
add_stat_legend(x)
plimits = ((3000, 6500), (-.3,3.2), (-.8,.6))
pbins = ((50,), (50,), (50,))
plt.sca(ax1)
plot_param_dist(summary[:,0], (plimits[0],pbins[0]), 'blue', r'$x_0$')
plt.sca(ax2)
plot_param_dist(summary[:,1], (plimits[1],pbins[1]), 'green', r'$a_1$')
plt.sca(ax3)
plot_param_dist(summary[:,2], (plimits[2],pbins[2]), 'red', r'$a_2$')
# plot the fit parameter distributions
def plot_param_scatter(x, y, xlim, ylim, xlabel, ylabel):
if args.mask_outliers:
mask = ~is_outlier(x, thresh=outlier_thres) & ~is_outlier(y, thresh=outlier_thres)
x = x[mask]
y = y[mask]
plt.plot(x, y, '+', ms=5)
plt.ylabel(ylabel)
plt.xlabel(xlabel)
plt.xlim(xlim)
plt.ylim(ylim)
plt.grid()
# calculate correlation coefficient
corr = np.corrcoef(x, y)
rho = corr[0,1]
# add text box
textstr = ''
textstr += '$\mathrm{N}=%d$\n' % len(x)
textstr += r'$\rho=%.2f$' % rho
props = dict(boxstyle='round', facecolor='white')
plt.text(0.95, 0.95, textstr, transform=plt.gca().transAxes, va='top', ha='right', bbox=props)
plt.sca(ax4)
plot_param_scatter(summary[:,0], summary[:,1], plimits[0], plimits[1], r'$x_0$', r'$a_1$')
plt.sca(ax5)
plot_param_scatter(summary[:,0], summary[:,2], plimits[0], plimits[2], r'$x_0$', r'$a_2$')
plt.sca(ax6)
plot_param_scatter(summary[:,1], summary[:,2], plimits[1], plimits[2], r'$a_1$', r'$a_2$')
plt.tight_layout()
fig.savefig(args.output)
if __name__ == '__main__':
main()
| mit |
orlox/hall_evolution | as_full/plotter.py | 1 | 4580 | #!/usr/bin/env python
"""
Program to produce graphs from the output of the as_toroidal program
"""
import matplotlib.pyplot as plt
from pylab import *
import sys
import os
import math
#get folder name, if not specified as argument, use the latest one
folder=""
if len(sys.argv)<2:
timestamp="0"
for root, dirs, files in os.walk("."):
for name in dirs:
if name[:8]=="results_" and len(name)==18:
newtimestamp=name[8:]
if newtimestamp>timestamp:
folder=name
timestamp=newtimestamp
else:
# First argument to program is folder with results
folder=sys.argv[1]
#add "/" if it is not given in folder name
if folder[len(folder)-1]!="/":
folder=folder+"/"
#Show what folder is being used
print("Plotting data in "+folder)
# Open parameters file
params=open(folder+'params.dat','r')
data=params.readline().split(":");
rNum=int(data[1])
data=params.readline().split(":");
thNum=int(data[1])
data=params.readline().split(":");
factor=float(data[1])
data=params.readline().split(":");
tNum=int(data[1])
data=params.readline().split(":");
plotSteps=int(data[1])
data=params.readline().split(":");
rmin=float(data[1])
data=params.readline().split(":");
thtd=float(data[1])
params.close()
#solve values of dr and dth
dr=(1.0-rmin)/(rNum-1)
dth=math.pi/(thNum-1)
#Create array to store A and B at each step
A=zeros((2*rNum-1,2*thNum-1));
B=zeros((rNum,thNum));
# make this smaller to increase the resolution
dx=0.005
# these variables are used by matplotlib
x = arange(0, 1, dx)
y = arange(-1, 1, dx)
X,Y = meshgrid(x, y)
ZA=zeros((len(x),len(y)))
ZB=zeros((len(x),len(y)))
#get place in grid that corresponds to each place in Z grid
grid=zeros((len(x),len(y),2))
i,j=0,0
for xvalue in x :
for yvalue in y:
r=math.sqrt(xvalue**2+yvalue**2)
th=math.acos(yvalue/r)
rStep=int((r-rmin+dr/2)/dr)
thStep=int((th+dth/2)/dth)
if rStep<=0 or rStep>=rNum or thStep==0 or thStep>=thNum:
grid[i][j][0]=0
grid[i][j][1]=0
j+=1
continue
grid[i][j][0]=rStep
grid[i][j][1]=thStep
j+=1
j=0
i+=1
k=0
while 1:
#do not plot this timestep if plot exists
#add zeros to the number of the plot, so they are ordered appropately
num_file=str(k)
diff_zeros=len(str(tNum))-len(str(k))
while diff_zeros>0:
num_file="0"+num_file
diff_zeros-=1
try:
data=open(folder+"plot_"+num_file+".png")
data.close()
k+=plotSteps
continue
except:
pass
#read A file
data
try:
data=open(folder+"A_"+str(k),'r')
except IOError as e:
break
#first line has simulation time
t=data.readline()
i,j=0,0
for line in data:
values=line.split(" ")
for value in values:
if j==thNum:
break
A[i][j]=float(value)
j+=1
j=0
i+=1
data.close()
#read B file
try:
data=open(folder+"B_"+str(k),'r')
except IOError as e:
break
#first line has simulation time
t=data.readline()
i,j=0,0
for line in data:
values=line.split(" ")
for value in values:
if j==thNum:
break
B[i][j]=float(value)
j+=1
j=0
i+=1
data.close()
i,j=0,0
for xvalue in x :
for yvalue in y:
ZA[i][j]=A[grid[i][j][0]][grid[i][j][1]]
ZB[i][j]=B[grid[i][j][0]][grid[i][j][1]]
j+=1
j=0
i+=1
fig=plt.figure()
#add data
figtext(0.02, 0.95, "Radial steps: "+str(rNum)+" Angular steps: "+str(thNum)+" Factor: "+str(factor)+ " t_h/t_d: "+str(thtd)+" t: "+t)
#figtext(0.25, 0.95, "Angular steps: "+str(thNum))
#figtext(0.45, 0.95, "Factor: "+str(factor))
#figtext(0.6, 0.95, "t_h/t_d: "+str(thtd))
#figtext(0.8, 0.95, "t: "+t)
#create plot
a=fig.add_subplot(1,2,1)
plt.imshow(ZA.T,extent=[0,1,-1,1],origin="lower")
plt.colorbar()
a.set_title("alpha")
a=fig.add_subplot(1,2,2)
plt.imshow(ZB.T,extent=[0,1,-1,1],origin="lower")
plt.colorbar()
a.set_title("beta")
#save to file
savefig(folder+"plot_"+num_file+".png", dpi=None, facecolor='w', edgecolor='w',
orientation='portrait', papertype=None, format=None,
transparent=False, bbox_inches=None, pad_inches=0.1)
close()
print num_file
k+=plotSteps
sys.exit()
| gpl-2.0 |
rew4332/tensorflow | tensorflow/examples/skflow/mnist_rnn.py | 14 | 2812 | # Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
This example builds rnn network for mnist data.
Borrowed structure from here: https://github.com/aymericdamien/TensorFlow-Examples/blob/master/examples/3%20-%20Neural%20Networks/recurrent_network.py
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from sklearn import metrics, preprocessing
import tensorflow as tf
from tensorflow.contrib import learn
# Parameters
learning_rate = 0.1
training_steps = 3000
batch_size = 128
# Network Parameters
n_input = 28 # MNIST data input (img shape: 28*28)
n_steps = 28 # timesteps
n_hidden = 128 # hidden layer num of features
n_classes = 10 # MNIST total classes (0-9 digits)
### Download and load MNIST data.
mnist = learn.datasets.load_dataset('mnist')
X_train = mnist.train.images
y_train = mnist.train.labels
X_test = mnist.test.images
y_test = mnist.test.labels
# It's useful to scale to ensure Stochastic Gradient Descent will do the right thing
scaler = preprocessing.StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.fit_transform(X_test)
def rnn_model(X, y):
X = tf.reshape(X, [-1, n_steps, n_input]) # (batch_size, n_steps, n_input)
# # permute n_steps and batch_size
X = tf.transpose(X, [1, 0, 2])
# # Reshape to prepare input to hidden activation
X = tf.reshape(X, [-1, n_input]) # (n_steps*batch_size, n_input)
# # Split data because rnn cell needs a list of inputs for the RNN inner loop
X = tf.split(0, n_steps, X) # n_steps * (batch_size, n_input)
# Define a GRU cell with tensorflow
lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(n_hidden)
# Get lstm cell output
_, encoding = tf.nn.rnn(lstm_cell, X, dtype=tf.float32)
return learn.models.logistic_regression(encoding, y)
classifier = learn.TensorFlowEstimator(model_fn=rnn_model, n_classes=n_classes,
batch_size=batch_size,
steps=training_steps,
learning_rate=learning_rate)
classifier.fit(X_train, y_train, logdir="/tmp/mnist_rnn")
score = metrics.accuracy_score(y_test, classifier.predict(X_test))
print('Accuracy: {0:f}'.format(score))
| apache-2.0 |
Frankkkkk/arctic | tests/unit/store/test_version_item.py | 2 | 1162 | import pandas as pd
from arctic.store.versioned_item import VersionedItem
def test_versioned_item_str():
item = VersionedItem(symbol="sym",
library="ONEMINUTE",
data=pd.DataFrame(),
version=1.0,
metadata={'metadata': 'foo'})
expected = "VersionedItem(symbol=sym,library=ONEMINUTE," + \
"data=<class 'pandas.core.frame.DataFrame'>,version=1.0,metadata={'metadata': 'foo'}"
assert str(item) == expected
assert repr(item) == expected
def test_versioned_item_str_handles_none():
item = VersionedItem(symbol=None,
library=None,
data=None,
version=None,
metadata=None)
assert str(item)
def test_versioned_item_metadata_dict():
item = VersionedItem(symbol="test",
library="test_lib",
data=None,
version=1.2,
metadata=None)
assert(item.metadata_dict() == {'symbol': 'test', 'library': 'test_lib', 'version': 1.2})
| lgpl-2.1 |
yidawang/brainiak | examples/factoranalysis/htfa_cv_example.py | 7 | 11484 | # Copyright 2016 Intel Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import sys
import math
import requests
import scipy.io
import numpy as np
from mpi4py import MPI
from subprocess import call
from scipy.stats import stats
from sklearn import model_selection
from sklearn.metrics import mean_squared_error
def recon_err(data, F, W):
"""Calcuate reconstruction error
Parameters
----------
data : 2D array
True data to recover.
F : 2D array
HTFA factor matrix.
W : 2D array
HTFA weight matrix.
Returns
-------
float
Returns root mean squared reconstruction error.
"""
recon = F.dot(W).ravel()
err = mean_squared_error(
data.ravel(),
recon,
multioutput='uniform_average')
return math.sqrt(err)
def get_train_err(htfa, data, F):
"""Calcuate training error
Parameters
----------
htfa : HTFA
An instance of HTFA, factor anaysis class in BrainIAK.
data : 2D array
Input data to HTFA.
F : 2D array
HTFA factor matrix.
Returns
-------
float
Returns root mean squared error on training.
"""
W = htfa.get_weights(data, F)
return recon_err(data, F, W)
def get_test_err(htfa, test_weight_data, test_recon_data,
test_weight_R, test_recon_R, centers, widths):
"""Calcuate test error
Parameters
----------
htfa : HTFA
An instance of HTFA, factor anaysis class in BrainIAK.
test_weigth_data : 2D array
Data used for testing weights.
test_recon_data : 2D array
Data used for testing reconstruction error.
test_weigth_R : 2D array
Coordinate matrix used for testing weights.
test_recon_R : 2D array
Coordinate matrix used for testing reconstruction error.
centers : 2D array
Center matrix of HTFA factors.
widths : 1D array
Width matrix of HTFA factors.
Returns
-------
float
Returns root mean squared error on test.
"""
# calculate F on test_weight_R, based on trained centers/widths
unique_R, inds = htfa.get_unique_R(test_weight_R)
F = htfa.get_factors(unique_R,
inds,
centers,
widths)
# calculate weights on test_weight_data
W = htfa.get_weights(test_weight_data, F)
# calculate F on final test_recon_data
unique_R, inds = htfa.get_unique_R(test_recon_R)
F = htfa.get_factors(unique_R,
inds,
centers,
widths)
return recon_err(test_recon_data, F, W)
n_subj = 2
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
group_id = int(rank/n_subj)
n_group = math.ceil(size/n_subj)
htfa_comm = comm.Split(group_id, rank)
htfa_rank = htfa_comm.Get_rank()
htfa_size = htfa_comm.Get_size()
if rank == 0:
import logging
logging.basicConfig(stream=sys.stdout, level=logging.INFO)
data_dir = os.path.join(os.getcwd(), 'data')
if rank == 0 and not os.path.exists(data_dir):
os.makedirs(data_dir)
url = []
url.append(' https://www.dropbox.com/s/r5s9tg4ekxzbrco/s0.mat?dl=0')
url.append(' https://www.dropbox.com/s/39tr01m76vxwaqa/s1.mat?dl=0')
for idx in range(n_subj):
if idx % size == rank:
file_name = os.path.join(data_dir, 's' + str(idx) + '.mat')
#check if file has already been downloaded
if not os.path.exists(file_name):
#check if URL exists
ret = requests.head(url[idx])
if ret.status_code == 200:
#download data
cmd = 'curl --location -o ' + file_name + url[idx]
try:
retcode = call(cmd, shell=True)
if retcode < 0:
print("File download was terminated by signal", -retcode, file=sys.stderr)
else:
print("File download returned", retcode, file=sys.stderr)
except OSError as e:
print("File download failed:", e, file=sys.stderr)
else:
print("File s%d.mat does not exist!\n"%idx)
comm.Barrier()
#get fMRI data and scanner RAS coordinates
data = []
R = []
mapping = {}
n_local_subj = 0
for idx in range(n_subj):
if idx % htfa_size == htfa_rank:
file_name = os.path.join(data_dir, 's' + str(idx) + '.mat')
all_data = scipy.io.loadmat(file_name)
bold = all_data['data']
# z-score the data
bold = stats.zscore(bold, axis=1, ddof=1)
data.append(bold)
R.append(all_data['R'])
mapping[str(n_local_subj)] = idx
n_local_subj += 1
min_K = 3
max_K = 6
n_K = 2
Ks = np.linspace(min_K, max_K, n_K, endpoint=True).astype(int)
n_splits = 3
# recon_err in shape n_splits*n_K
test_recon_errs = np.zeros((n_subj, n_splits, n_K))
tmp_test_recon_errs = np.zeros((n_subj, n_splits, n_K))
train_recon_errs = np.zeros((n_subj, n_splits, n_K))
tmp_train_recon_errs = np.zeros((n_subj, n_splits, n_K))
local_size = math.ceil(n_subj/size)
if n_local_subj > 0:
from brainiak.factoranalysis.htfa import HTFA
n_voxel, n_tr = data[0].shape
n_dim = R[0].shape[1]
test_size = 0.3
rnd_seed_voxel = 30000
rnd_seed_tr = 3000
tr_solver = 'exact'
nlss_method = 'dogbox'
nlss_loss = 'linear'
upper_ratio = 1.8
lower_ratio = 0.1
voxel_ratio = 0.25
tr_ratio = 0.1
max_voxel = 2000
max_tr = 200
max_sample_voxel = min(max_voxel,
int(voxel_ratio * n_voxel))
max_sample_tr = min(max_tr, int(tr_ratio * n_tr))
#split voxel and TR for two-level cross validation
ss_voxel = model_selection.ShuffleSplit(
n_splits=n_splits,
test_size=test_size,
random_state=rnd_seed_voxel)
voxel_indices = np.arange(n_voxel)
ss_voxel.get_n_splits(voxel_indices)
ss_tr = model_selection.ShuffleSplit(
n_splits=n_splits,
test_size=test_size,
random_state=rnd_seed_tr)
tr_indices = np.arange(n_tr)
ss_tr.get_n_splits(tr_indices)
train_voxels = []
test_voxels = []
train_trs = []
test_trs = []
for train_index, test_index in ss_voxel.split(voxel_indices):
train_voxels.append(train_index)
test_voxels.append(test_index)
for train_index, test_index in ss_tr.split(tr_indices):
train_trs.append(train_index)
test_trs.append(test_index)
for p in range(n_splits):
for idx in range(n_K):
index = p*n_K + idx
if index % n_group == group_id:
#split data and R
train_voxel_indices = train_voxels[p]
test_voxel_indices = test_voxels[p]
train_tr_indices = train_trs[p]
test_tr_indices = test_trs[p]
train_data = []
total_test_data = []
test_weight_data = []
test_recon_data = []
test_weight_R = []
test_recon_R = []
for s in range(n_local_subj):
train_data.append(data[s][:, train_tr_indices])
total_test_data.append(data[s][:, test_tr_indices])
test_weight_data.append(
total_test_data[s][train_voxel_indices, :])
test_recon_data.append(
total_test_data[s][test_voxel_indices, :])
test_weight_R.append(R[s][train_voxel_indices])
test_recon_R.append(R[s][test_voxel_indices])
htfa = HTFA(K=Ks[idx],
max_global_iter=5,
max_local_iter=2,
n_subj=n_subj,
nlss_method=nlss_method,
nlss_loss=nlss_loss,
tr_solver=tr_solver,
upper_ratio=upper_ratio,
lower_ratio=lower_ratio,
max_tr=max_sample_tr,
max_voxel=max_sample_voxel,
comm=htfa_comm,
verbose=True)
htfa.fit(train_data, R)
for s in range(n_local_subj):
#get posterior for each subject
subj_idx = mapping[str(s)]
start_idx = s * htfa.prior_size
end_idx = (s + 1) * htfa.prior_size
local_posteiror = htfa.local_posterior_[start_idx:end_idx]
local_centers = htfa.get_centers(local_posteiror)
local_widths = htfa.get_widths(local_posteiror)
htfa.n_dim = n_dim
htfa.cov_vec_size = np.sum(np.arange(htfa.n_dim) + 1)
htfa.map_offset = htfa.get_map_offset()
#training happens on all voxels, but part of TRs
unique_R_all, inds_all = htfa.get_unique_R(R[s])
train_F = htfa.get_factors(unique_R_all,
inds_all,
local_centers,
local_widths)
#calculate train_recon_err
tmp_train_recon_errs[subj_idx, p,idx] = get_train_err(htfa,
train_data[s],
train_F)
#calculate weights on test_weight_data, test_recon_err on test_recon_data
tmp_test_recon_errs[subj_idx, p,idx] = get_test_err(htfa,
test_weight_data[s],
test_recon_data[s],
test_weight_R[s],
test_recon_R[s],
local_centers,
local_widths)
comm.Reduce(tmp_test_recon_errs, test_recon_errs, op=MPI.SUM)
comm.Reduce(tmp_train_recon_errs, train_recon_errs, op=MPI.SUM)
if rank == 0:
errs = train_recon_errs.reshape(n_subj * n_splits, n_K)
mean_errs = np.average(errs, axis=0)
print("train error on each K is\n")
print(mean_errs)
errs = test_recon_errs.reshape(n_subj * n_splits, n_K)
mean_errs = np.average(errs, axis=0)
print("test error on each K is\n")
print(mean_errs)
best_idx = np.argmin(mean_errs)
print("best K for test recon is %d " % (Ks[best_idx]))
| apache-2.0 |
martinwicke/tensorflow | tensorflow/contrib/learn/python/learn/learn_io/io_test.py | 20 | 5003 | # Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""tf.learn IO operation tests."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import random
import tensorflow as tf
from tensorflow.contrib.learn.python import learn
from tensorflow.contrib.learn.python.learn import datasets
from tensorflow.contrib.learn.python.learn.estimators._sklearn import accuracy_score
# pylint: disable=wildcard-import
from tensorflow.contrib.learn.python.learn.learn_io import *
# pylint: enable=wildcard-import
class IOTest(tf.test.TestCase):
# pylint: disable=undefined-variable
"""tf.learn IO operation tests."""
def test_pandas_dataframe(self):
if HAS_PANDAS:
import pandas as pd # pylint: disable=g-import-not-at-top
random.seed(42)
iris = datasets.load_iris()
data = pd.DataFrame(iris.data)
labels = pd.DataFrame(iris.target)
classifier = learn.LinearClassifier(
feature_columns=learn.infer_real_valued_columns_from_input(data),
n_classes=3)
classifier.fit(data, labels, steps=100)
score = accuracy_score(labels[0], list(classifier.predict(data)))
self.assertGreater(score, 0.5, "Failed with score = {0}".format(score))
else:
print("No pandas installed. pandas-related tests are skipped.")
def test_pandas_series(self):
if HAS_PANDAS:
import pandas as pd # pylint: disable=g-import-not-at-top
random.seed(42)
iris = datasets.load_iris()
data = pd.DataFrame(iris.data)
labels = pd.Series(iris.target)
classifier = learn.LinearClassifier(
feature_columns=learn.infer_real_valued_columns_from_input(data),
n_classes=3)
classifier.fit(data, labels, steps=100)
score = accuracy_score(labels, list(classifier.predict(data)))
self.assertGreater(score, 0.5, "Failed with score = {0}".format(score))
def test_string_data_formats(self):
if HAS_PANDAS:
import pandas as pd # pylint: disable=g-import-not-at-top
with self.assertRaises(ValueError):
learn.io.extract_pandas_data(pd.DataFrame({"Test": ["A", "B"]}))
with self.assertRaises(ValueError):
learn.io.extract_pandas_labels(pd.DataFrame({"Test": ["A", "B"]}))
def test_dask_io(self):
if HAS_DASK and HAS_PANDAS:
import pandas as pd # pylint: disable=g-import-not-at-top
import dask.dataframe as dd # pylint: disable=g-import-not-at-top
# test dask.dataframe
df = pd.DataFrame(
dict(a=list("aabbcc"), b=list(range(6))),
index=pd.date_range(start="20100101", periods=6))
ddf = dd.from_pandas(df, npartitions=3)
extracted_ddf = extract_dask_data(ddf)
self.assertEqual(
extracted_ddf.divisions, (0, 2, 4, 6),
"Failed with divisions = {0}".format(extracted_ddf.divisions))
self.assertEqual(
extracted_ddf.columns.tolist(), ["a", "b"],
"Failed with columns = {0}".format(extracted_ddf.columns))
# test dask.series
labels = ddf["a"]
extracted_labels = extract_dask_labels(labels)
self.assertEqual(
extracted_labels.divisions, (0, 2, 4, 6),
"Failed with divisions = {0}".format(extracted_labels.divisions))
# labels should only have one column
with self.assertRaises(ValueError):
extract_dask_labels(ddf)
else:
print("No dask installed. dask-related tests are skipped.")
def test_dask_iris_classification(self):
if HAS_DASK and HAS_PANDAS:
import pandas as pd # pylint: disable=g-import-not-at-top
import dask.dataframe as dd # pylint: disable=g-import-not-at-top
random.seed(42)
iris = datasets.load_iris()
data = pd.DataFrame(iris.data)
data = dd.from_pandas(data, npartitions=2)
labels = pd.DataFrame(iris.target)
labels = dd.from_pandas(labels, npartitions=2)
classifier = learn.LinearClassifier(
feature_columns=learn.infer_real_valued_columns_from_input(data),
n_classes=3)
classifier.fit(data, labels, steps=100)
predictions = data.map_partitions(classifier.predict).compute()
score = accuracy_score(labels.compute(), predictions)
self.assertGreater(score, 0.5, "Failed with score = {0}".format(score))
if __name__ == "__main__":
tf.test.main()
| apache-2.0 |
AnoshZahir/Greengraph | Greengraph/Test/test_map.py | 1 | 2863 | from ..graph import Greengraph
from ..map import Map
import requests
import numpy as np
import matplotlib
import os
import yaml
from nose.tools import assert_called_with, assert_equal
from mock import patch
@patch.object(requests, 'get')
@patch.object(matplotlib.image, 'imread')
def test_build_default_params(mock_imread, mock_get):
with open(os.path.join(os.path.dirname(__file__),'data','map_data.yaml')) as dataset:
map_data = yaml.load(dataset)['test_map']
for data in map_data:
test = data.pop('test')
url = data.pop('url')
latitude = data.pop('latitude')
longitude = data.pop('longitude')
params = data.pop('params')
if (test == 'default'):
actual_map = Map(latitude,longitude)
elif (test == 'satellite_false'):
actual_map = Map(latitude,longitude,satellite = False)
elif (test == 'zoom'):
actual_map = Map(latitude,longitude,zoom = 30)
elif (test == 'size'):
actual_map = Map(latitude,longitude,size = (300,300))
elif (test == 'sensor_true'):
actual_map = Map(latitude,longitude,sensor = True)
mock_get.assert_called_with(url,params=params)
@patch.object(requests, 'get')
@patch(matplotlib.image, 'imread')
#@patch.object(Map, 'green')
def test_green(mock_imread, mock_get):
'''
Test that the function can take a 3d matrix, and return a matrix of true/false values.
Data is taken from the 'test_green' subsection of map_data.yaml.
'''
my_map = Map(51.50, -0.12)
with open(os.path.join(os.path.dirname(__file__), 'data', 'map_data.yaml')) as dataset:
map_data = yaml.load(dataset)['test_green']
for data in map_data:
threshold = data.pop('test')
input_matrix = data.pop('3d_input_matrix')
expected_return = data.pop('2d_output_matrix')
my_map.__setattr__('pixels', input_matrix)
actual_return = my_map.green(threshold)
assert_equal(expected_return, actual_return)
@patch.object(Map, 'green')
def test_count_green(mock_green):
'''
Test that a 2d input matrix of true/false values is correctly summed.
Data is taken from the 'test_count_green' subsection of map_data.yaml.
'''
my_map = Map(51.50, -0.12)
with open(os.path.join(os.path.dirname(__file__), 'data', 'map_data.yaml')) as dataset:
map_data = yaml.load(dataset)['test_count_green']
for data in map_data:
input_values = data.pop('input_values')
expected_return = data.pop('result')
mock_green.return_value = input_values
actual_return = my_map.count_green() #threshold kept unchanged for this test.
assert_equal(actual_return, expected_return) | mit |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.